LibreOffice
LibreOffice 7.5 SDK C/C++ API Reference
ustring.hxx
Go to the documentation of this file.
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_USTRING_HXX
25 #define INCLUDED_RTL_USTRING_HXX
26 
27 #include "sal/config.h"
28 
29 #include <cassert>
30 #include <cstddef>
31 #include <cstdlib>
32 #include <limits>
33 #include <new>
34 #include <ostream>
35 #include <utility>
36 
37 #if defined LIBO_INTERNAL_ONLY
38 #include <string_view>
39 #include <type_traits>
40 #endif
41 
42 #include "rtl/ustring.h"
43 #include "rtl/string.hxx"
44 #include "rtl/stringutils.hxx"
45 #include "rtl/textenc.h"
46 
47 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
48 #include "config_global.h"
49 #include "rtl/stringconcat.hxx"
50 #endif
51 
52 #ifdef RTL_STRING_UNITTEST
53 extern bool rtl_string_unittest_invalid_conversion;
54 #endif
55 
56 // The unittest uses slightly different code to help check that the proper
57 // calls are made. The class is put into a different namespace to make
58 // sure the compiler generates a different (if generating also non-inline)
59 // copy of the function and does not merge them together. The class
60 // is "brought" into the proper rtl namespace by a typedef below.
61 #ifdef RTL_STRING_UNITTEST
62 #define rtl rtlunittest
63 #endif
64 
65 namespace rtl
66 {
67 
68 class OUStringBuffer;
69 
70 #ifdef RTL_STRING_UNITTEST
71 #undef rtl
72 #endif
73 
74 #if defined LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
75 
83 template<std::size_t N> class SAL_WARN_UNUSED OUStringLiteral {
84  static_assert(N != 0);
85  static_assert(N - 1 <= std::numeric_limits<sal_Int32>::max(), "literal too long");
86  friend class OUString;
87  friend class OUStringConstExpr;
88 
89 public:
90 #if HAVE_CPP_CONSTEVAL
91  consteval
92 #else
93  constexpr
94 #endif
95  OUStringLiteral(char16_t const (&literal)[N]) {
96  assertLayout();
97  assert(literal[N - 1] == '\0');
98  //TODO: Use C++20 constexpr std::copy_n (P0202R3):
99  for (std::size_t i = 0; i != N; ++i) {
100  more.buffer[i] = literal[i];
101  }
102  }
103 
104  constexpr sal_Int32 getLength() const { return more.length; }
105 
106  constexpr sal_Unicode const * getStr() const SAL_RETURNS_NONNULL { return more.buffer; }
107 
108  constexpr operator std::u16string_view() const { return {more.buffer, sal_uInt32(more.length)}; }
109 
110 private:
111  static constexpr void assertLayout() {
112  // These static_asserts verifying the layout compatibility with rtl_uString cannot be class
113  // member declarations, as offsetof requires a complete type, so defer them to here:
114  static_assert(std::is_standard_layout_v<OUStringLiteral>);
115  static_assert(offsetof(OUStringLiteral, str.refCount) == offsetof(OUStringLiteral, more.refCount));
116  static_assert(offsetof(OUStringLiteral, str.length) == offsetof(OUStringLiteral, more.length));
117  static_assert(offsetof(OUStringLiteral, str.buffer) == offsetof(OUStringLiteral, more.buffer));
118  }
119 
120  struct Data {
121  Data() = default;
122 
123  oslInterlockedCount refCount = 0x40000000; // SAL_STRING_STATIC_FLAG (sal/rtl/strimp.hxx)
124  sal_Int32 length = N - 1;
125  sal_Unicode buffer[N] = {}; //TODO: drop initialization for C++20 (P1331R2)
126  };
127 
128  union {
129  rtl_uString str;
130  Data more = {};
131  };
132 };
133 
134 #if defined RTL_STRING_UNITTEST
135 namespace libreoffice_internal {
136 template<std::size_t N> struct ExceptConstCharArrayDetector<OUStringLiteral<N>> {};
137 template<std::size_t N> struct ExceptCharArrayDetector<OUStringLiteral<N>> {};
138 }
139 #endif
140 
149 class OUString;
150 class OUStringConstExpr
151 {
152 public:
153  template<std::size_t N> constexpr OUStringConstExpr(OUStringLiteral<N> const & literal):
154  pData(const_cast<rtl_uString *>(&literal.str)) {}
155 
156  // prevent mis-use
157  template<std::size_t N> constexpr OUStringConstExpr(OUStringLiteral<N> && literal)
158  = delete;
159 
160  // no destructor necessary because we know we are pointing at a compile-time
161  // constant OUStringLiteral, which bypasses ref-counting.
162 
166  constexpr std::u16string_view asView() const { return std::u16string_view(pData->buffer, pData->length); }
167 
168  inline operator const OUString&() const;
169 
170 private:
171  rtl_uString* pData;
172 };
173 
175 #endif
176 
177 /* ======================================================================= */
178 
202 class SAL_WARN_UNUSED SAL_DLLPUBLIC_RTTI OUString
203 {
204 public:
206  rtl_uString * pData;
208 
213  {
214  pData = NULL;
215  rtl_uString_new( &pData );
216  }
217 
223  OUString( const OUString & str )
224  {
225  pData = str.pData;
226  rtl_uString_acquire( pData );
227  }
228 
229 #if defined LIBO_INTERNAL_ONLY
230 
236  OUString( OUString && str ) noexcept
237  {
238  pData = str.pData;
239  str.pData = nullptr;
240  rtl_uString_new( &str.pData );
241  }
242 #endif
243 
249  OUString( rtl_uString * str )
250  {
251  pData = str;
252  rtl_uString_acquire( pData );
253  }
254 
263  OUString( rtl_uString * str, __sal_NoAcquire )
264  { pData = str; }
265 
271  explicit OUString( sal_Unicode value )
272  : pData (NULL)
273  {
274  rtl_uString_newFromStr_WithLength( &pData, &value, 1 );
275  }
276 
277 #if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST_CONCAT
278  // Catch inadvertent conversions to the above ctor (but still allow
280  // construction from char literals):
281  OUString(int) = delete;
282  explicit OUString(char c):
283  OUString(sal_Unicode(static_cast<unsigned char>(c)))
284  {}
286 #endif
287 
288 #if defined LIBO_INTERNAL_ONLY
289 
290  template<typename T> explicit OUString(
291  T const & value,
292  typename libreoffice_internal::CharPtrDetector<T, libreoffice_internal::Dummy>::TypeUtf16
293  = libreoffice_internal::Dummy()):
294  pData(nullptr)
295  { rtl_uString_newFromStr(&pData, value); }
296 
297  template<typename T> explicit OUString(
298  T & value,
299  typename
300  libreoffice_internal::NonConstCharArrayDetector<T, libreoffice_internal::Dummy>::TypeUtf16
301  = libreoffice_internal::Dummy()):
302  pData(nullptr)
303  { rtl_uString_newFromStr(&pData, value); }
304 
305 #else
306 
312  OUString( const sal_Unicode * value )
313  {
314  pData = NULL;
315  rtl_uString_newFromStr( &pData, value );
316  }
317 
318 #endif
319 
328  OUString( const sal_Unicode * value, sal_Int32 length )
329  {
330  pData = NULL;
331  rtl_uString_newFromStr_WithLength( &pData, value, length );
332  }
333 
349  template< typename T >
351  {
352  assert(
354  pData = NULL;
356  rtl_uString_new(&pData);
357  } else {
359  &pData,
361  literal),
363  }
364 #ifdef RTL_STRING_UNITTEST
365  rtl_string_unittest_const_literal = true;
366 #endif
367  }
368 
369 #if defined LIBO_INTERNAL_ONLY
370 
371  template<typename T> OUString(
372  T & literal,
374  T, libreoffice_internal::Dummy>::TypeUtf16
376  pData(nullptr)
377  {
378  assert(
381  rtl_uString_new(&pData);
382  } else {
384  &pData,
385  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
386  literal),
387  libreoffice_internal::ConstCharArrayDetector<T>::length);
388  }
389  }
390 #endif
391 
392 #if defined LIBO_INTERNAL_ONLY && defined RTL_STRING_UNITTEST
393 
398  template< typename T >
399  OUString( T&, typename libreoffice_internal::ExceptConstCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
400  {
401  pData = NULL;
402  rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
403  rtl_string_unittest_invalid_conversion = true;
404  }
409  template< typename T >
410  OUString( const T&, typename libreoffice_internal::ExceptCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
411  {
412  pData = NULL;
413  rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
414  rtl_string_unittest_invalid_conversion = true;
415  }
417 #endif
418 
419 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
420 
426  template<std::size_t N> constexpr OUString(OUStringLiteral<N> const & literal):
427  pData(const_cast<rtl_uString *>(&literal.str)) {}
428  template<std::size_t N> OUString(OUStringLiteral<N> &&) = delete;
430 #endif
431 
446  OUString( const char * value, sal_Int32 length,
447  rtl_TextEncoding encoding,
448  sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
449  {
450  pData = NULL;
451  rtl_string2UString( &pData, value, length, encoding, convertFlags );
452  if (pData == NULL) {
453  throw std::bad_alloc();
454  }
455  }
456 
473  explicit OUString(
474  sal_uInt32 const * codePoints, sal_Int32 codePointCount):
475  pData(NULL)
476  {
477  rtl_uString_newFromCodePoints(&pData, codePoints, codePointCount);
478  if (pData == NULL) {
479  throw std::bad_alloc();
480  }
481  }
482 
483 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
484 
488  template< typename T1, typename T2 >
489  OUString( OUStringConcat< T1, T2 >&& c )
490  {
491  const sal_Int32 l = c.length();
492  pData = rtl_uString_alloc( l );
493  if (l != 0)
494  {
495  sal_Unicode* end = c.addData( pData->buffer );
496  pData->length = l;
497  *end = '\0';
498  }
499  }
500 
505  template< typename T, std::size_t N >
506  OUString( StringNumberBase< sal_Unicode, T, N >&& n )
507  : OUString( n.buf, n.length )
508  {}
509 #endif
510 
511 #if defined LIBO_INTERNAL_ONLY
512  explicit OUString(std::u16string_view sv) {
513  if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
514  throw std::bad_alloc();
515  }
516  pData = nullptr;
517  rtl_uString_newFromStr_WithLength(&pData, sv.data(), sv.size());
518  }
519 #endif
520 
525  {
526  rtl_uString_release( pData );
527  }
528 
540  static OUString const & unacquired( rtl_uString * const * ppHandle )
541  { return * reinterpret_cast< OUString const * >( ppHandle ); }
542 
543 #if defined LIBO_INTERNAL_ONLY
544 
556  static OUString const& unacquired(const OUStringBuffer& str);
557 #endif
558 
564  OUString & operator=( const OUString & str )
565  {
566  rtl_uString_assign( &pData, str.pData );
567  return *this;
568  }
569 
570 #if defined LIBO_INTERNAL_ONLY
571 
577  OUString & operator=( OUString && str ) noexcept
578  {
579  std::swap(pData, str.pData);
580  return *this;
581  }
582 #endif
583 
596  template< typename T >
598  {
599  assert(
602  rtl_uString_new(&pData);
603  } else {
605  &pData,
607  literal),
609  }
610  return *this;
611  }
612 
613 #if defined LIBO_INTERNAL_ONLY
614 
615  template<typename T>
616  typename
618  operator =(T & literal) {
620  rtl_uString_new(&pData);
621  } else {
623  &pData,
624  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
625  literal),
626  libreoffice_internal::ConstCharArrayDetector<T>::length);
627  }
628  return *this;
629  }
630 
632  template<std::size_t N> OUString & operator =(OUStringLiteral<N> const & literal) {
633  rtl_uString_release(pData);
634  pData = const_cast<rtl_uString *>(&literal.str);
635  return *this;
636  }
637  template<std::size_t N> OUString & operator =(OUStringLiteral<N> &&) = delete;
638 
639  template <typename T, std::size_t N>
640  OUString & operator =(StringNumberBase<sal_Unicode, T, N> && n) {
641  // n.length should never be zero, so no need to add an optimization for that case
642  rtl_uString_newFromStr_WithLength(&pData, n.buf, n.length);
643  return *this;
644  }
645 
646  OUString & operator =(std::u16string_view sv) {
647  if (sv.empty()) {
648  rtl_uString_new(&pData);
649  } else {
650  rtl_uString_newFromStr_WithLength(&pData, sv.data(), sv.size());
651  }
652  return *this;
653  }
654 #endif
655 
656 #if defined LIBO_INTERNAL_ONLY
657 
665  inline OUString & operator+=( const OUStringBuffer & str ) &;
666 #endif
667 
675  OUString & operator+=( const OUString & str )
676 #if defined LIBO_INTERNAL_ONLY
677  &
678 #endif
679  {
680  return internalAppend(str.pData);
681  }
682 #if defined LIBO_INTERNAL_ONLY
683  void operator+=(OUString const &) && = delete;
684 #endif
685 
692  template<typename T>
694  operator +=(T & literal)
695 #if defined LIBO_INTERNAL_ONLY
696  &
697 #endif
698  {
699  assert(
702  &pData, pData,
705  return *this;
706  }
707 #if defined LIBO_INTERNAL_ONLY
708  template<typename T>
710  operator +=(T &) && = delete;
711 #endif
712 
713 #if defined LIBO_INTERNAL_ONLY
714 
715  template<typename T>
716  typename
718  operator +=(T & literal) & {
720  &pData, pData,
723  return *this;
724  }
725  template<typename T>
726  typename
727  libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
728  operator +=(T &) && = delete;
729 
731  template<std::size_t N> OUString & operator +=(OUStringLiteral<N> const & literal) & {
732  rtl_uString_newConcatUtf16L(&pData, pData, literal.getStr(), literal.getLength());
733  return *this;
734  }
735  template<std::size_t N> void operator +=(OUStringLiteral<N> const &) && = delete;
736 
737  OUString & operator +=(std::u16string_view sv) & {
738  if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
739  throw std::bad_alloc();
740  }
741  rtl_uString_newConcatUtf16L(&pData, pData, sv.data(), sv.size());
742  return *this;
743  }
744  void operator +=(std::u16string_view) && = delete;
745 #endif
746 
747 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
748 
752  template< typename T1, typename T2 >
753  OUString& operator+=( OUStringConcat< T1, T2 >&& c ) & {
754  sal_Int32 l = c.length();
755  if( l == 0 )
756  return *this;
757  l += pData->length;
758  rtl_uString_ensureCapacity( &pData, l );
759  sal_Unicode* end = c.addData( pData->buffer + pData->length );
760  *end = '\0';
761  pData->length = l;
762  return *this;
763  }
764  template<typename T1, typename T2> void operator +=(
765  OUStringConcat<T1, T2> &&) && = delete;
766 
771  template< typename T, std::size_t N >
772  OUString& operator+=( StringNumberBase< sal_Unicode, T, N >&& n ) & {
773  sal_Int32 l = n.length;
774  if( l == 0 )
775  return *this;
776  l += pData->length;
777  rtl_uString_ensureCapacity( &pData, l );
778  sal_Unicode* end = addDataHelper( pData->buffer + pData->length, n.buf, n.length );
779  *end = '\0';
780  pData->length = l;
781  return *this;
782  }
783  template<typename T, std::size_t N> void operator +=(
784  StringNumberBase<sal_Unicode, T, N> &&) && = delete;
785 #endif
786 
791  void clear()
792  {
793  rtl_uString_new( &pData );
794  }
795 
804  sal_Int32 getLength() const { return pData->length; }
805 
814  bool isEmpty() const
815  {
816  return pData->length == 0;
817  }
818 
826  const sal_Unicode * getStr() const SAL_RETURNS_NONNULL { return pData->buffer; }
827 
837  sal_Unicode operator [](sal_Int32 index) const {
838  // silence spurious -Werror=strict-overflow warnings from GCC 4.8.2
839  assert(index >= 0 && static_cast<sal_uInt32>(index) < static_cast<sal_uInt32>(getLength()));
840  return getStr()[index];
841  }
842 
855 #if defined LIBO_INTERNAL_ONLY
856  sal_Int32 compareTo( std::u16string_view str ) const
857  {
858  return rtl_ustr_compare_WithLength( pData->buffer, pData->length,
859  str.data(), str.length() );
860  }
861 #else
862  sal_Int32 compareTo( const OUString & str ) const
863  {
864  return rtl_ustr_compare_WithLength( pData->buffer, pData->length,
865  str.pData->buffer, str.pData->length );
866  }
867 #endif
868 
884 #if defined LIBO_INTERNAL_ONLY
885  sal_Int32 compareTo( std::u16string_view str, sal_Int32 maxLength ) const
886  {
887  return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length,
888  str.data(), str.length(), maxLength );
889  }
890 #else
891  sal_Int32 compareTo( const OUString & str, sal_Int32 maxLength ) const
892  {
893  return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length,
894  str.pData->buffer, str.pData->length, maxLength );
895  }
896 #endif
897 
910 #if defined LIBO_INTERNAL_ONLY
911  sal_Int32 reverseCompareTo(std::u16string_view sv) const {
913  pData->buffer, pData->length, sv.data(), sv.size());
914  }
915 #else
916  sal_Int32 reverseCompareTo( const OUString & str ) const
917  {
918  return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
919  str.pData->buffer, str.pData->length );
920  }
921 #endif
922 
928  template< typename T >
930  {
931  assert(
934  pData->buffer, pData->length,
937  }
938 
950  bool equals( const OUString & str ) const
951  {
952  if ( pData->length != str.pData->length )
953  return false;
954  if ( pData == str.pData )
955  return true;
956  return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
957  str.pData->buffer, str.pData->length ) == 0;
958  }
959 
974 #if defined LIBO_INTERNAL_ONLY
975  bool equalsIgnoreAsciiCase(std::u16string_view sv) const {
976  if ( sal_uInt32(pData->length) != sv.size() )
977  return false;
978  if ( pData->buffer == sv.data() )
979  return true;
980  return
982  pData->buffer, pData->length, sv.data(), sv.size())
983  == 0;
984  }
985 #else
986  bool equalsIgnoreAsciiCase( const OUString & str ) const
987  {
988  if ( pData->length != str.pData->length )
989  return false;
990  if ( pData == str.pData )
991  return true;
992  return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
993  str.pData->buffer, str.pData->length ) == 0;
994  }
995 #endif
996 
1012 #if defined LIBO_INTERNAL_ONLY
1013  sal_Int32 compareToIgnoreAsciiCase(std::u16string_view sv) const {
1015  pData->buffer, pData->length, sv.data(), sv.size());
1016  }
1017 #else
1018  sal_Int32 compareToIgnoreAsciiCase( const OUString & str ) const
1019  {
1020  return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
1021  str.pData->buffer, str.pData->length );
1022  }
1023 #endif
1024 
1030  template< typename T >
1032  {
1033  assert(
1035  return
1036  (pData->length
1039  pData->buffer, pData->length,
1041  literal))
1042  == 0);
1043  }
1044 
1060 #if defined LIBO_INTERNAL_ONLY
1061  bool match(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
1062  return
1064  pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size(),
1065  sv.size())
1066  == 0;
1067  }
1068 #else
1069  bool match( const OUString & str, sal_Int32 fromIndex = 0 ) const
1070  {
1071  return rtl_ustr_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
1072  str.pData->buffer, str.pData->length, str.pData->length ) == 0;
1073  }
1074 #endif
1075 
1081  template< typename T >
1082  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type match( T& literal, sal_Int32 fromIndex = 0 ) const
1083  {
1084  assert(
1086  return
1088  pData->buffer+fromIndex, pData->length-fromIndex,
1090  literal),
1092  == 0;
1093  }
1094 
1113 #if defined LIBO_INTERNAL_ONLY
1114  bool matchIgnoreAsciiCase(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
1115  return
1117  pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size(),
1118  sv.size())
1119  == 0;
1120  }
1121 #else
1122  bool matchIgnoreAsciiCase( const OUString & str, sal_Int32 fromIndex = 0 ) const
1123  {
1124  return rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
1125  str.pData->buffer, str.pData->length,
1126  str.pData->length ) == 0;
1127  }
1128 #endif
1129 
1135  template< typename T >
1136  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const
1137  {
1138  assert(
1140  return matchIgnoreAsciiCaseAsciiL(
1143  }
1144 
1161  sal_Int32 compareToAscii( const char* asciiStr ) const
1162  {
1163  return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length, asciiStr );
1164  }
1165 
1189  "replace s1.compareToAscii(s2, strlen(s2)) == 0 with s1.startsWith(s2)")
1190  sal_Int32 compareToAscii( const char * asciiStr, sal_Int32 maxLength ) const
1191  {
1192  return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer, pData->length,
1193  asciiStr, maxLength );
1194  }
1195 
1214  sal_Int32 reverseCompareToAsciiL( const char * asciiStr, sal_Int32 asciiStrLength ) const
1215  {
1216  return rtl_ustr_asciil_reverseCompare_WithLength( pData->buffer, pData->length,
1217  asciiStr, asciiStrLength );
1218  }
1219 
1235  bool equalsAscii( const char* asciiStr ) const
1236  {
1237  return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length,
1238  asciiStr ) == 0;
1239  }
1240 
1257  bool equalsAsciiL( const char* asciiStr, sal_Int32 asciiStrLength ) const
1258  {
1259  if ( pData->length != asciiStrLength )
1260  return false;
1261 
1263  pData->buffer, asciiStr, asciiStrLength );
1264  }
1265 
1284  bool equalsIgnoreAsciiCaseAscii( const char * asciiStr ) const
1285  {
1286  return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
1287  }
1288 
1307  sal_Int32 compareToIgnoreAsciiCaseAscii( const char * asciiStr ) const
1308  {
1309  return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr );
1310  }
1311 
1331  bool equalsIgnoreAsciiCaseAsciiL( const char * asciiStr, sal_Int32 asciiStrLength ) const
1332  {
1333  if ( pData->length != asciiStrLength )
1334  return false;
1335 
1336  return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
1337  }
1338 
1359  bool matchAsciiL( const char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const
1360  {
1361  return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
1362  asciiStr, asciiStrLength ) == 0;
1363  }
1364 
1365  // This overload is left undefined, to detect calls of matchAsciiL that
1366  // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
1367  // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
1368  // platforms):
1369 #if SAL_TYPES_SIZEOFLONG == 8
1370  void matchAsciiL(char const *, sal_Int32, rtl_TextEncoding) const;
1371 #endif
1372 
1396  bool matchIgnoreAsciiCaseAsciiL( const char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const
1397  {
1398  return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
1399  asciiStr, asciiStrLength ) == 0;
1400  }
1401 
1402  // This overload is left undefined, to detect calls of
1403  // matchIgnoreAsciiCaseAsciiL that erroneously use
1404  // RTL_CONSTASCII_USTRINGPARAM instead of RTL_CONSTASCII_STRINGPARAM (but
1405  // would lead to ambiguities on 32 bit platforms):
1406 #if SAL_TYPES_SIZEOFLONG == 8
1407  void matchIgnoreAsciiCaseAsciiL(char const *, sal_Int32, rtl_TextEncoding)
1408  const;
1409 #endif
1410 
1425 #if defined LIBO_INTERNAL_ONLY
1426  bool startsWith(std::u16string_view sv, OUString * rest = nullptr) const {
1427  auto const b = match(sv);
1428  if (b && rest != nullptr) {
1429  *rest = copy(sv.size());
1430  }
1431  return b;
1432  }
1433 #else
1434  bool startsWith(OUString const & str, OUString * rest = NULL) const {
1435  bool b = match(str);
1436  if (b && rest != NULL) {
1437  *rest = copy(str.getLength());
1438  }
1439  return b;
1440  }
1441 #endif
1442 
1448  template< typename T >
1450  T & literal, OUString * rest = NULL) const
1451  {
1452  assert(
1454  bool b
1456  <= sal_uInt32(pData->length))
1458  pData->buffer,
1460  literal),
1462  if (b && rest != NULL) {
1463  *rest = copy(
1465  }
1466  return b;
1467  }
1468 
1489 #if defined LIBO_INTERNAL_ONLY
1490  bool startsWithIgnoreAsciiCase(std::u16string_view sv, OUString * rest = nullptr) const {
1491  auto const b = matchIgnoreAsciiCase(sv);
1492  if (b && rest != nullptr) {
1493  *rest = copy(sv.size());
1494  }
1495  return b;
1496  }
1497 #else
1498  bool startsWithIgnoreAsciiCase(OUString const & str, OUString * rest = NULL)
1499  const
1500  {
1501  bool b = matchIgnoreAsciiCase(str);
1502  if (b && rest != NULL) {
1503  *rest = copy(str.getLength());
1504  }
1505  return b;
1506  }
1507 #endif
1508 
1514  template< typename T >
1516  startsWithIgnoreAsciiCase(T & literal, OUString * rest = NULL) const
1517  {
1518  assert(
1520  bool b
1522  <= sal_uInt32(pData->length))
1524  pData->buffer,
1527  literal),
1529  == 0);
1530  if (b && rest != NULL) {
1531  *rest = copy(
1533  }
1534  return b;
1535  }
1536 
1551 #if defined LIBO_INTERNAL_ONLY
1552  bool endsWith(std::u16string_view sv, OUString * rest = nullptr) const {
1553  auto const b = sv.size() <= sal_uInt32(pData->length)
1554  && match(sv, pData->length - sv.size());
1555  if (b && rest != nullptr) {
1556  *rest = copy(0, (pData->length - sv.size()));
1557  }
1558  return b;
1559  }
1560 #else
1561  bool endsWith(OUString const & str, OUString * rest = NULL) const {
1562  bool b = str.getLength() <= getLength()
1563  && match(str, getLength() - str.getLength());
1564  if (b && rest != NULL) {
1565  *rest = copy(0, getLength() - str.getLength());
1566  }
1567  return b;
1568  }
1569 #endif
1570 
1576  template< typename T >
1578  endsWith(T & literal, OUString * rest = NULL) const
1579  {
1580  assert(
1582  bool b
1584  <= sal_uInt32(pData->length))
1586  (pData->buffer + pData->length
1589  literal),
1591  if (b && rest != NULL) {
1592  *rest = copy(
1593  0,
1594  (getLength()
1596  }
1597  return b;
1598  }
1599 
1611  bool endsWithAsciiL(char const * asciiStr, sal_Int32 asciiStrLength)
1612  const
1613  {
1614  return asciiStrLength <= pData->length
1616  pData->buffer + pData->length - asciiStrLength, asciiStr,
1617  asciiStrLength);
1618  }
1619 
1640 #if defined LIBO_INTERNAL_ONLY
1641  bool endsWithIgnoreAsciiCase(std::u16string_view sv, OUString * rest = nullptr) const {
1642  auto const b = sv.size() <= sal_uInt32(pData->length)
1643  && matchIgnoreAsciiCase(sv, pData->length - sv.size());
1644  if (b && rest != nullptr) {
1645  *rest = copy(0, pData->length - sv.size());
1646  }
1647  return b;
1648  }
1649 #else
1650  bool endsWithIgnoreAsciiCase(OUString const & str, OUString * rest = NULL) const
1651  {
1652  bool b = str.getLength() <= getLength()
1653  && matchIgnoreAsciiCase(str, getLength() - str.getLength());
1654  if (b && rest != NULL) {
1655  *rest = copy(0, getLength() - str.getLength());
1656  }
1657  return b;
1658  }
1659 #endif
1660 
1666  template< typename T >
1668  endsWithIgnoreAsciiCase(T & literal, OUString * rest = NULL) const
1669  {
1670  assert(
1672  bool b
1674  <= sal_uInt32(pData->length))
1676  (pData->buffer + pData->length
1680  literal),
1682  == 0);
1683  if (b && rest != NULL) {
1684  *rest = copy(
1685  0,
1686  (getLength()
1688  }
1689  return b;
1690  }
1691 
1703  char const * asciiStr, sal_Int32 asciiStrLength) const
1704  {
1705  return asciiStrLength <= pData->length
1707  pData->buffer + pData->length - asciiStrLength,
1708  asciiStrLength, asciiStr, asciiStrLength)
1709  == 0);
1710  }
1711 
1712  friend bool operator == ( const OUString& rStr1, const OUString& rStr2 )
1713  { return rStr1.equals(rStr2); }
1714 
1715  friend bool operator != ( const OUString& rStr1, const OUString& rStr2 )
1716  { return !(operator == ( rStr1, rStr2 )); }
1717 
1718  friend bool operator < ( const OUString& rStr1, const OUString& rStr2 )
1719  { return rStr1.compareTo( rStr2 ) < 0; }
1720  friend bool operator > ( const OUString& rStr1, const OUString& rStr2 )
1721  { return rStr1.compareTo( rStr2 ) > 0; }
1722  friend bool operator <= ( const OUString& rStr1, const OUString& rStr2 )
1723  { return rStr1.compareTo( rStr2 ) <= 0; }
1724  friend bool operator >= ( const OUString& rStr1, const OUString& rStr2 )
1725  { return rStr1.compareTo( rStr2 ) >= 0; }
1726 
1727 #if defined LIBO_INTERNAL_ONLY
1728 
1729  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
1730  operator ==(OUString const & s1, T const & s2) {
1732  == 0;
1733  }
1734 
1735  template<typename T>
1736  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
1737  operator ==(OUString const & s1, T & s2) {
1738  return rtl_ustr_compare_WithLength(s1.getStr(), s1.getLength(), s2, rtl_ustr_getLength(s2))
1739  == 0;
1740  }
1741 
1742  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
1743  operator ==(T const & s1, OUString const & s2) {
1744  return rtl_ustr_compare_WithLength(s1, rtl_ustr_getLength(s1), s2.getStr(), s2.getLength())
1745  == 0;
1746  }
1747 
1748  template<typename T>
1749  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
1750  operator ==(T & s1, OUString const & s2) {
1751  return rtl_ustr_compare_WithLength(s1, rtl_ustr_getLength(s1), s2.getStr(), s2.getLength())
1752  == 0;
1753  }
1754 
1755  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
1756  operator !=(OUString const & s1, T const & s2) { return !(s1 == s2); }
1757 
1758  template<typename T>
1759  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
1760  operator !=(OUString const & s1, T & s2) { return !(s1 == s2); }
1761 
1762  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
1763  operator !=(T const & s1, OUString const & s2) { return !(s1 == s2); }
1764 
1765  template<typename T>
1766  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
1767  operator !=(T & s1, OUString const & s2) { return !(s1 == s2); }
1768 
1769 #else
1770 
1771  friend bool operator == ( const OUString& rStr1, const sal_Unicode * pStr2 )
1772  { return rStr1.compareTo( pStr2 ) == 0; }
1773  friend bool operator == ( const sal_Unicode * pStr1, const OUString& rStr2 )
1774  { return OUString( pStr1 ).compareTo( rStr2 ) == 0; }
1775 
1776  friend bool operator != ( const OUString& rStr1, const sal_Unicode * pStr2 )
1777  { return !(operator == ( rStr1, pStr2 )); }
1778  friend bool operator != ( const sal_Unicode * pStr1, const OUString& rStr2 )
1779  { return !(operator == ( pStr1, rStr2 )); }
1780 
1781 #endif
1782 
1790  template< typename T >
1792  {
1793  assert(
1795  return rString.equalsAsciiL(
1798  }
1806  template< typename T >
1808  {
1809  assert(
1811  return rString.equalsAsciiL(
1814  }
1822  template< typename T >
1824  {
1825  assert(
1827  return !rString.equalsAsciiL(
1830  }
1838  template< typename T >
1840  {
1841  assert(
1843  return !rString.equalsAsciiL(
1846  }
1847 
1848 #if defined LIBO_INTERNAL_ONLY
1849 
1850  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
1851  operator ==(OUString const & string, T & literal) {
1852  return
1854  string.pData->buffer, string.pData->length,
1856  literal),
1858  == 0;
1859  }
1861  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
1862  operator ==(T & literal, OUString const & string) {
1863  return
1865  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
1866  literal),
1867  libreoffice_internal::ConstCharArrayDetector<T>::length,
1868  string.pData->buffer, string.pData->length)
1869  == 0;
1870  }
1872  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
1873  operator !=(OUString const & string, T & literal) {
1874  return
1876  string.pData->buffer, string.pData->length,
1877  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
1878  literal),
1879  libreoffice_internal::ConstCharArrayDetector<T>::length)
1880  != 0;
1881  }
1883  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
1884  operator !=(T & literal, OUString const & string) {
1885  return
1887  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
1888  literal),
1889  libreoffice_internal::ConstCharArrayDetector<T>::length,
1890  string.pData->buffer, string.pData->length)
1891  != 0;
1892  }
1893 #endif
1894 
1902  sal_Int32 hashCode() const
1903  {
1904  return rtl_ustr_hashCode_WithLength( pData->buffer, pData->length );
1905  }
1906 
1920  sal_Int32 indexOf( sal_Unicode ch, sal_Int32 fromIndex = 0 ) const
1921  {
1922  sal_Int32 ret = rtl_ustr_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
1923  return (ret < 0 ? ret : ret+fromIndex);
1924  }
1925 
1935  sal_Int32 lastIndexOf( sal_Unicode ch ) const
1936  {
1937  return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
1938  }
1939 
1952  sal_Int32 lastIndexOf( sal_Unicode ch, sal_Int32 fromIndex ) const
1953  {
1954  return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
1955  }
1956 
1972 #if defined LIBO_INTERNAL_ONLY
1973  sal_Int32 indexOf(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
1974  auto const n = rtl_ustr_indexOfStr_WithLength(
1975  pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size());
1976  return n < 0 ? n : n + fromIndex;
1977  }
1978 #else
1979  sal_Int32 indexOf( const OUString & str, sal_Int32 fromIndex = 0 ) const
1980  {
1981  sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
1982  str.pData->buffer, str.pData->length );
1983  return (ret < 0 ? ret : ret+fromIndex);
1984  }
1985 #endif
1986 
1992  template< typename T >
1993  typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const
1994  {
1995  assert(
1997  sal_Int32 n = rtl_ustr_indexOfAscii_WithLength(
1998  pData->buffer + fromIndex, pData->length - fromIndex,
2001  return n < 0 ? n : n + fromIndex;
2002  }
2003 
2027  sal_Int32 indexOfAsciiL(
2028  char const * str, sal_Int32 len, sal_Int32 fromIndex = 0) const
2029  {
2030  sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
2031  pData->buffer + fromIndex, pData->length - fromIndex, str, len);
2032  return ret < 0 ? ret : ret + fromIndex;
2033  }
2034 
2035  // This overload is left undefined, to detect calls of indexOfAsciiL that
2036  // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
2037  // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
2038  // platforms):
2039 #if SAL_TYPES_SIZEOFLONG == 8
2040  void indexOfAsciiL(char const *, sal_Int32 len, rtl_TextEncoding) const;
2041 #endif
2042 
2058 #if defined LIBO_INTERNAL_ONLY
2059  sal_Int32 lastIndexOf(std::u16string_view sv) const {
2061  pData->buffer, pData->length, sv.data(), sv.size());
2062  }
2063 #else
2064  sal_Int32 lastIndexOf( const OUString & str ) const
2065  {
2066  return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length,
2067  str.pData->buffer, str.pData->length );
2068  }
2069 #endif
2070 
2088 #if defined LIBO_INTERNAL_ONLY
2089  sal_Int32 lastIndexOf(std::u16string_view sv, sal_Int32 fromIndex) const {
2090  return rtl_ustr_lastIndexOfStr_WithLength(pData->buffer, fromIndex, sv.data(), sv.size());
2091  }
2092 #else
2093  sal_Int32 lastIndexOf( const OUString & str, sal_Int32 fromIndex ) const
2094  {
2095  return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
2096  str.pData->buffer, str.pData->length );
2097  }
2098 #endif
2099 
2105  template< typename T >
2107  {
2108  assert(
2111  pData->buffer, pData->length,
2114  }
2115 
2135  sal_Int32 lastIndexOfAsciiL(char const * str, sal_Int32 len) const
2136  {
2138  pData->buffer, pData->length, str, len);
2139  }
2140 
2151  SAL_WARN_UNUSED_RESULT OUString copy( sal_Int32 beginIndex ) const
2152  {
2153  return copy(beginIndex, getLength() - beginIndex);
2154  }
2155 
2168  SAL_WARN_UNUSED_RESULT OUString copy( sal_Int32 beginIndex, sal_Int32 count ) const
2169  {
2170  rtl_uString *pNew = NULL;
2171  rtl_uString_newFromSubString( &pNew, pData, beginIndex, count );
2172  return OUString( pNew, SAL_NO_ACQUIRE );
2173  }
2174 
2175 #if defined LIBO_INTERNAL_ONLY
2176 
2186  SAL_WARN_UNUSED_RESULT std::u16string_view subView( sal_Int32 beginIndex ) const
2187  {
2188  assert(beginIndex >= 0);
2189  assert(beginIndex <= getLength());
2190  return subView(beginIndex, getLength() - beginIndex);
2191  }
2192 
2205  SAL_WARN_UNUSED_RESULT std::u16string_view subView( sal_Int32 beginIndex, sal_Int32 count ) const
2206  {
2207  assert(beginIndex >= 0);
2208  assert(count >= 0);
2209  assert(beginIndex <= getLength());
2210  assert(count <= getLength() - beginIndex);
2211  return std::u16string_view(*this).substr(beginIndex, count);
2212  }
2213 #endif
2214 
2215 #ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
2216 
2225  {
2226  rtl_uString* pNew = NULL;
2227  rtl_uString_newConcat( &pNew, pData, str.pData );
2228  return OUString( pNew, SAL_NO_ACQUIRE );
2229  }
2230 #endif
2231 
2232 #ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
2233  friend OUString operator+( const OUString& rStr1, const OUString& rStr2 )
2234  {
2235  return rStr1.concat( rStr2 );
2236  }
2237 #endif
2238 
2239 // hide this from internal code to avoid ambiguous lookup error
2240 #ifndef LIBO_INTERNAL_ONLY
2241 
2254  SAL_WARN_UNUSED_RESULT OUString replaceAt( sal_Int32 index, sal_Int32 count, const OUString& newStr ) const
2255  {
2256  rtl_uString* pNew = NULL;
2257  rtl_uString_newReplaceStrAt( &pNew, pData, index, count, newStr.pData );
2258  return OUString( pNew, SAL_NO_ACQUIRE );
2259  }
2260 #endif
2261 
2262 #ifdef LIBO_INTERNAL_ONLY
2263  SAL_WARN_UNUSED_RESULT OUString replaceAt( sal_Int32 index, sal_Int32 count, std::u16string_view newStr ) const
2264  {
2265  rtl_uString* pNew = NULL;
2266  rtl_uString_newReplaceStrAtUtf16L( &pNew, pData, index, count, newStr.data(), newStr.size() );
2267  return OUString( pNew, SAL_NO_ACQUIRE );
2268  }
2269 #endif
2270 
2285  {
2286  rtl_uString* pNew = NULL;
2287  rtl_uString_newReplace( &pNew, pData, oldChar, newChar );
2288  return OUString( pNew, SAL_NO_ACQUIRE );
2289  }
2290 
2309 #if defined LIBO_INTERNAL_ONLY
2310  [[nodiscard]] OUString replaceFirst(
2311  std::u16string_view from, std::u16string_view to, sal_Int32 * index = nullptr) const
2312  {
2313  rtl_uString * s = nullptr;
2314  sal_Int32 i = 0;
2316  &s, pData, from.data(), from.size(), to.data(), to.size(),
2317  index == nullptr ? &i : index);
2318  return OUString(s, SAL_NO_ACQUIRE);
2319  }
2320 #else
2322  OUString const & from, OUString const & to, sal_Int32 * index = NULL) const
2323  {
2324  rtl_uString * s = NULL;
2325  sal_Int32 i = 0;
2327  &s, pData, from.pData, to.pData, index == NULL ? &i : index);
2328  return OUString(s, SAL_NO_ACQUIRE);
2329  }
2330 #endif
2331 
2350 #if defined LIBO_INTERNAL_ONLY
2351  template<typename T> [[nodiscard]]
2353  T & from, std::u16string_view to, sal_Int32 * index = nullptr) const
2354  {
2356  rtl_uString * s = nullptr;
2357  sal_Int32 i = 0;
2361  index == nullptr ? &i : index);
2362  return OUString(s, SAL_NO_ACQUIRE);
2363  }
2364 #else
2365  template< typename T >
2367  sal_Int32 * index = NULL) const
2368  {
2370  rtl_uString * s = NULL;
2371  sal_Int32 i = 0;
2373  &s, pData,
2376  index == NULL ? &i : index);
2377  return OUString(s, SAL_NO_ACQUIRE);
2378  }
2379 #endif
2380 
2399 #if defined LIBO_INTERNAL_ONLY
2400  template<typename T> [[nodiscard]]
2402  std::u16string_view from, T & to, sal_Int32 * index = nullptr) const
2403  {
2405  rtl_uString * s = nullptr;
2406  sal_Int32 i = 0;
2408  &s, pData, from.data(), from.size(),
2410  libreoffice_internal::ConstCharArrayDetector<T>::length, index == nullptr ? &i : index);
2411  return OUString(s, SAL_NO_ACQUIRE);
2412  }
2413 #else
2414  template< typename T >
2416  sal_Int32 * index = NULL) const
2417  {
2419  rtl_uString * s = NULL;
2420  sal_Int32 i = 0;
2422  &s, pData, from.pData,
2425  index == NULL ? &i : index);
2426  return OUString(s, SAL_NO_ACQUIRE);
2427  }
2428 #endif
2429 
2448  template< typename T1, typename T2 >
2450  replaceFirst( T1& from, T2& to, sal_Int32 * index = NULL) const
2451  {
2454  rtl_uString * s = NULL;
2455  sal_Int32 i = 0;
2457  &s, pData,
2462  index == NULL ? &i : index);
2463  return OUString(s, SAL_NO_ACQUIRE);
2464  }
2465 
2481 #if defined LIBO_INTERNAL_ONLY
2482  [[nodiscard]] OUString replaceAll(
2483  std::u16string_view from, std::u16string_view to, sal_Int32 fromIndex = 0) const
2484  {
2485  rtl_uString * s = nullptr;
2486  rtl_uString_newReplaceAllFromIndexUtf16LUtf16L(
2487  &s, pData, from.data(), from.size(), to.data(), to.size(), fromIndex);
2488  return OUString(s, SAL_NO_ACQUIRE);
2489  }
2490 #else
2492  OUString const & from, OUString const & to, sal_Int32 fromIndex = 0) const
2493  {
2494  rtl_uString * s = NULL;
2495  rtl_uString_newReplaceAllFromIndex(&s, pData, from.pData, to.pData, fromIndex);
2496  return OUString(s, SAL_NO_ACQUIRE);
2497  }
2498 #endif
2499 
2513 #if defined LIBO_INTERNAL_ONLY
2514  template<typename T> [[nodiscard]]
2516  T & from, std::u16string_view to) const
2517  {
2519  rtl_uString * s = nullptr;
2523  return OUString(s, SAL_NO_ACQUIRE);
2524  }
2525 #else
2526  template< typename T >
2528  {
2530  rtl_uString * s = NULL;
2532  &s, pData,
2535  return OUString(s, SAL_NO_ACQUIRE);
2536  }
2537 #endif
2538 
2552 #if defined LIBO_INTERNAL_ONLY
2553  template<typename T> [[nodiscard]]
2555  std::u16string_view from, T & to) const
2556  {
2558  rtl_uString * s = nullptr;
2560  &s, pData, from.data(), from.size(),
2563  return OUString(s, SAL_NO_ACQUIRE);
2564  }
2565 #else
2566  template< typename T >
2568  {
2570  rtl_uString * s = NULL;
2572  &s, pData, from.pData,
2575  return OUString(s, SAL_NO_ACQUIRE);
2576  }
2577 #endif
2578 
2592  template< typename T1, typename T2 >
2594  replaceAll( T1& from, T2& to ) const
2595  {
2598  rtl_uString * s = NULL;
2600  &s, pData,
2605  return OUString(s, SAL_NO_ACQUIRE);
2606  }
2607 
2619  {
2620  rtl_uString* pNew = NULL;
2621  rtl_uString_newToAsciiLowerCase( &pNew, pData );
2622  return OUString( pNew, SAL_NO_ACQUIRE );
2623  }
2624 
2636  {
2637  rtl_uString* pNew = NULL;
2638  rtl_uString_newToAsciiUpperCase( &pNew, pData );
2639  return OUString( pNew, SAL_NO_ACQUIRE );
2640  }
2641 
2656  {
2657  rtl_uString* pNew = NULL;
2658  rtl_uString_newTrim( &pNew, pData );
2659  return OUString( pNew, SAL_NO_ACQUIRE );
2660  }
2661 
2686  OUString getToken( sal_Int32 token, sal_Unicode cTok, sal_Int32& index ) const
2687  {
2688  rtl_uString * pNew = NULL;
2689  index = rtl_uString_getToken( &pNew, pData, token, cTok, index );
2690  return OUString( pNew, SAL_NO_ACQUIRE );
2691  }
2692 
2706  OUString getToken(sal_Int32 count, sal_Unicode separator) const {
2707  sal_Int32 n = 0;
2708  return getToken(count, separator, n);
2709  }
2710 
2719  bool toBoolean() const
2720  {
2721  return rtl_ustr_toBoolean( pData->buffer );
2722  }
2723 
2731  {
2732  return pData->buffer[0];
2733  }
2734 
2745  sal_Int32 toInt32( sal_Int16 radix = 10 ) const
2746  {
2747  return rtl_ustr_toInt32( pData->buffer, radix );
2748  }
2749 
2762  sal_uInt32 toUInt32( sal_Int16 radix = 10 ) const
2763  {
2764  return rtl_ustr_toUInt32( pData->buffer, radix );
2765  }
2766 
2777  sal_Int64 toInt64( sal_Int16 radix = 10 ) const
2778  {
2779  return rtl_ustr_toInt64( pData->buffer, radix );
2780  }
2781 
2794  sal_uInt64 toUInt64( sal_Int16 radix = 10 ) const
2795  {
2796  return rtl_ustr_toUInt64( pData->buffer, radix );
2797  }
2798 
2807  float toFloat() const
2808  {
2809  return rtl_ustr_toFloat( pData->buffer );
2810  }
2811 
2820  double toDouble() const
2821  {
2822  return rtl_ustr_toDouble( pData->buffer );
2823  }
2824 
2825 
2842  {
2843  rtl_uString * pNew = NULL;
2844  rtl_uString_intern( &pNew, pData );
2845  if (pNew == NULL) {
2846  throw std::bad_alloc();
2847  }
2848  return OUString( pNew, SAL_NO_ACQUIRE );
2849  }
2850 
2876  static OUString intern( const char * value, sal_Int32 length,
2877  rtl_TextEncoding encoding,
2878  sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS,
2879  sal_uInt32 *pInfo = NULL )
2880  {
2881  rtl_uString * pNew = NULL;
2882  rtl_uString_internConvert( &pNew, value, length, encoding,
2883  convertFlags, pInfo );
2884  if (pNew == NULL) {
2885  throw std::bad_alloc();
2886  }
2887  return OUString( pNew, SAL_NO_ACQUIRE );
2888  }
2889 
2914  bool convertToString(OString * pTarget, rtl_TextEncoding nEncoding,
2915  sal_uInt32 nFlags) const
2916  {
2917  return rtl_convertUStringToString(&pTarget->pData, pData->buffer,
2918  pData->length, nEncoding, nFlags);
2919  }
2920 
2972  sal_uInt32 iterateCodePoints(
2973  sal_Int32 * indexUtf16, sal_Int32 incrementCodePoints = 1) const
2974  {
2976  pData, indexUtf16, incrementCodePoints);
2977  }
2978 
2988 #if defined LIBO_INTERNAL_ONLY
2989  static OUString fromUtf8(std::string_view rSource)
2990  {
2991  OUString aTarget;
2992  bool bSuccess = rtl_convertStringToUString(&aTarget.pData,
2993  rSource.data(),
2994  rSource.length(),
2997  (void) bSuccess;
2998  assert(bSuccess);
2999  return aTarget;
3000  }
3001 #else
3002  static OUString fromUtf8(const OString& rSource)
3003  {
3004  OUString aTarget;
3005  bool bSuccess = rtl_convertStringToUString(&aTarget.pData,
3006  rSource.getStr(),
3007  rSource.getLength(),
3010  (void) bSuccess;
3011  assert(bSuccess);
3012  return aTarget;
3013  }
3014 #endif
3015 
3026  OString toUtf8() const
3027  {
3028  OString aTarget;
3029  bool bSuccess = rtl_convertUStringToString(&aTarget.pData,
3030  getStr(),
3031  getLength(),
3034  (void) bSuccess;
3035  assert(bSuccess);
3036  return aTarget;
3037  }
3038 
3039 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
3040 
3041  static OUStringNumber< int > number( int i, sal_Int16 radix = 10 )
3042  {
3043  return OUStringNumber< int >( i, radix );
3044  }
3045  static OUStringNumber< long long > number( long long ll, sal_Int16 radix = 10 )
3046  {
3047  return OUStringNumber< long long >( ll, radix );
3048  }
3049  static OUStringNumber< unsigned long long > number( unsigned long long ll, sal_Int16 radix = 10 )
3050  {
3051  return OUStringNumber< unsigned long long >( ll, radix );
3052  }
3053  static OUStringNumber< unsigned long long > number( unsigned int i, sal_Int16 radix = 10 )
3054  {
3055  return number( static_cast< unsigned long long >( i ), radix );
3056  }
3057  static OUStringNumber< long long > number( long i, sal_Int16 radix = 10)
3058  {
3059  return number( static_cast< long long >( i ), radix );
3060  }
3061  static OUStringNumber< unsigned long long > number( unsigned long i, sal_Int16 radix = 10 )
3062  {
3063  return number( static_cast< unsigned long long >( i ), radix );
3064  }
3065  static OUStringNumber< float > number( float f )
3066  {
3067  return OUStringNumber< float >( f );
3068  }
3069  static OUStringNumber< double > number( double d )
3070  {
3071  return OUStringNumber< double >( d );
3072  }
3073 #else
3074 
3084  static OUString number( int i, sal_Int16 radix = 10 )
3085  {
3087  return OUString(aBuf, rtl_ustr_valueOfInt32(aBuf, i, radix));
3088  }
3091  static OUString number( unsigned int i, sal_Int16 radix = 10 )
3092  {
3093  return number( static_cast< unsigned long long >( i ), radix );
3094  }
3097  static OUString number( long i, sal_Int16 radix = 10)
3098  {
3099  return number( static_cast< long long >( i ), radix );
3100  }
3103  static OUString number( unsigned long i, sal_Int16 radix = 10 )
3104  {
3105  return number( static_cast< unsigned long long >( i ), radix );
3106  }
3109  static OUString number( long long ll, sal_Int16 radix = 10 )
3110  {
3112  return OUString(aBuf, rtl_ustr_valueOfInt64(aBuf, ll, radix));
3113  }
3116  static OUString number( unsigned long long ll, sal_Int16 radix = 10 )
3117  {
3119  return OUString(aBuf, rtl_ustr_valueOfUInt64(aBuf, ll, radix));
3120  }
3121 
3131  static OUString number( float f )
3132  {
3134  return OUString(aBuf, rtl_ustr_valueOfFloat(aBuf, f));
3135  }
3136 
3146  static OUString number( double d )
3147  {
3149  return OUString(aBuf, rtl_ustr_valueOfDouble(aBuf, d));
3150  }
3151 #endif
3152 
3164  SAL_DEPRECATED("use boolean()") static OUString valueOf( sal_Bool b )
3165  {
3166  return boolean(b);
3167  }
3168 
3180  static OUString boolean( bool b )
3181  {
3183  return OUString(aBuf, rtl_ustr_valueOfBoolean(aBuf, b));
3184  }
3185 
3193  SAL_DEPRECATED("convert to OUString or use directly") static OUString valueOf( sal_Unicode c )
3194  {
3195  return OUString( &c, 1 );
3196  }
3197 
3208  SAL_DEPRECATED("use number()") static OUString valueOf( sal_Int32 i, sal_Int16 radix = 10 )
3209  {
3210  return number( i, radix );
3211  }
3212 
3223  SAL_DEPRECATED("use number()") static OUString valueOf( sal_Int64 ll, sal_Int16 radix = 10 )
3224  {
3225  return number( ll, radix );
3226  }
3227 
3237  SAL_DEPRECATED("use number()") static OUString valueOf( float f )
3238  {
3239  return number(f);
3240  }
3241 
3251  SAL_DEPRECATED("use number()") static OUString valueOf( double d )
3252  {
3253  return number(d);
3254  }
3255 
3271  static OUString createFromAscii( const char * value )
3272  {
3273  rtl_uString* pNew = NULL;
3274  rtl_uString_newFromAscii( &pNew, value );
3275  return OUString( pNew, SAL_NO_ACQUIRE );
3276  }
3277 
3278 #if defined LIBO_INTERNAL_ONLY
3279  static OUString createFromAscii(std::string_view value) {
3280  rtl_uString * p = nullptr;
3281  rtl_uString_newFromLiteral(&p, value.data(), value.size(), 0); //TODO: check for overflow
3282  return OUString(p, SAL_NO_ACQUIRE);
3283  }
3284  #endif
3285 
3286 #if defined LIBO_INTERNAL_ONLY
3287  operator std::u16string_view() const { return {getStr(), sal_uInt32(getLength())}; }
3288 #endif
3289 
3290 #if defined LIBO_INTERNAL_ONLY
3291  // A wrapper for the first expression in an
3292  //
3293  // OUString::Concat(e1) + e2 + ...
3294  //
3295  // concatenation chain, when neither of the first two e1, e2 is one of our rtl string-related
3296  // classes (so something like
3297  //
3298  // OUString s = "a" + (b ? std::u16string_view(u"c") : std::u16string_view(u"dd"));
3299  //
3300  // would not compile):
3301  template<typename T> [[nodiscard]] static
3302  OUStringConcat<OUStringConcatMarker, T>
3303  Concat(T const & value) { return OUStringConcat<OUStringConcatMarker, T>({}, value); }
3304 
3305  // This overload is needed so that an argument of type 'char const[N]' ends up as
3306  // 'OUStringConcat<rtl::OUStringConcatMarker, char const[N]>' rather than as
3307  // 'OUStringConcat<rtl::OUStringConcatMarker, char[N]>':
3308  template<typename T, std::size_t N> [[nodiscard]] static
3309  OUStringConcat<OUStringConcatMarker, T[N]>
3310  Concat(T (& value)[N]) { return OUStringConcat<OUStringConcatMarker, T[N]>({}, value); }
3311 #endif
3312 
3313 private:
3314  OUString & internalAppend( rtl_uString* pOtherData )
3315  {
3316  rtl_uString* pNewData = NULL;
3317  rtl_uString_newConcat( &pNewData, pData, pOtherData );
3318  if (pNewData == NULL) {
3319  throw std::bad_alloc();
3320  }
3321  rtl_uString_assign(&pData, pNewData);
3322  rtl_uString_release(pNewData);
3323  return *this;
3324  }
3325 
3326 };
3327 
3328 #if defined LIBO_INTERNAL_ONLY
3329 // Can only define this after we define OUString
3330 inline OUStringConstExpr::operator const OUString &() const { return OUString::unacquired(&pData); }
3331 #endif
3332 
3333 #if defined LIBO_INTERNAL_ONLY
3334 // Prevent the operator ==/!= overloads with 'sal_Unicode const *' parameter from
3335 // being selected for nonsensical code like
3336 //
3337 // if (ouIdAttr == nullptr)
3338 //
3339 void operator ==(OUString const &, std::nullptr_t) = delete;
3340 void operator ==(std::nullptr_t, OUString const &) = delete;
3341 void operator !=(OUString const &, std::nullptr_t) = delete;
3342 void operator !=(std::nullptr_t, OUString const &) = delete;
3343 #endif
3344 
3345 #if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
3346 inline bool operator ==(OUString const & lhs, StringConcatenation<char16_t> const & rhs)
3347 { return lhs == std::u16string_view(rhs); }
3348 inline bool operator !=(OUString const & lhs, StringConcatenation<char16_t> const & rhs)
3349 { return lhs != std::u16string_view(rhs); }
3350 inline bool operator ==(StringConcatenation<char16_t> const & lhs, OUString const & rhs)
3351 { return std::u16string_view(lhs) == rhs; }
3352 inline bool operator !=(StringConcatenation<char16_t> const & lhs, OUString const & rhs)
3353 { return std::u16string_view(lhs) != rhs; }
3354 #endif
3355 
3356 #if defined LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
3357 
3362 template<>
3363 struct ToStringHelper< OUString >
3364 {
3365  static std::size_t length( const OUString& s ) { return s.getLength(); }
3366  sal_Unicode* operator() ( sal_Unicode* buffer, const OUString& s ) const { return addDataHelper( buffer, s.getStr(), s.getLength()); }
3367 };
3368 
3372 template<std::size_t N>
3373 struct ToStringHelper< OUStringLiteral<N> >
3374 {
3375  static std::size_t length( const OUStringLiteral<N>& str ) { return str.getLength(); }
3376  sal_Unicode* operator()( sal_Unicode* buffer, const OUStringLiteral<N>& str ) const { return addDataHelper( buffer, str.getStr(), str.getLength() ); }
3377 };
3378 
3382 template< typename charT, typename traits, typename T1, typename T2 >
3383 inline std::basic_ostream<charT, traits> & operator <<(
3384  std::basic_ostream<charT, traits> & stream, OUStringConcat< T1, T2 >&& concat)
3385 {
3386  return stream << OUString( std::move(concat) );
3387 }
3388 
3390 #endif
3391 
3398 {
3408  size_t operator()(const OUString& rString) const
3409  { return static_cast<size_t>(rString.hashCode()); }
3410 };
3411 
3412 /* ======================================================================= */
3413 
3431 #if defined LIBO_INTERNAL_ONLY
3432 inline OUString OStringToOUString( std::string_view rStr,
3433  rtl_TextEncoding encoding,
3434  sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
3435 {
3436  return OUString( rStr.data(), rStr.length(), encoding, convertFlags );
3437 }
3438 #else
3439 inline OUString OStringToOUString( const OString & rStr,
3440  rtl_TextEncoding encoding,
3441  sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
3442 {
3443  return OUString( rStr.getStr(), rStr.getLength(), encoding, convertFlags );
3444 }
3445 #endif
3446 
3464 #if defined LIBO_INTERNAL_ONLY
3465 inline OString OUStringToOString( std::u16string_view rUnicode,
3466  rtl_TextEncoding encoding,
3467  sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
3468 {
3469  return OString( rUnicode.data(), rUnicode.length(), encoding, convertFlags );
3470 }
3471 #else
3472 inline OString OUStringToOString( const OUString & rUnicode,
3473  rtl_TextEncoding encoding,
3474  sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
3475 {
3476  return OString( rUnicode.getStr(), rUnicode.getLength(), encoding, convertFlags );
3477 }
3478 #endif
3479 
3480 /* ======================================================================= */
3481 
3490 template< typename charT, typename traits >
3491 inline std::basic_ostream<charT, traits> & operator <<(
3492  std::basic_ostream<charT, traits> & stream, OUString const & rString)
3493 {
3494  return stream <<
3496  // best effort; potentially loses data due to conversion failures
3497  // (stray surrogate halves) and embedded null characters
3498 }
3499 
3500 } // namespace
3501 
3502 #ifdef RTL_STRING_UNITTEST
3503 namespace rtl
3504 {
3505 typedef rtlunittest::OUString OUString;
3506 }
3507 #endif
3508 
3509 // In internal code, allow to use classes like OUString without having to
3510 // explicitly refer to the rtl namespace, which is kind of superfluous given
3511 // that OUString itself is namespaced by its OU prefix:
3512 #if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
3513 using ::rtl::OUString;
3514 using ::rtl::OUStringHash;
3517 using ::rtl::OUStringLiteral;
3518 using ::rtl::OUStringChar;
3519 using ::rtl::Concat2View;
3520 #endif
3521 
3523 
3528 #if defined LIBO_INTERNAL_ONLY
3529 namespace std {
3530 
3531 template<>
3532 struct hash<::rtl::OUString>
3533 {
3534  std::size_t operator()(::rtl::OUString const & s) const
3535  {
3536  if constexpr (sizeof(std::size_t) == 8)
3537  {
3538  // return a hash that uses the full 64-bit range instead of a 32-bit value
3539  size_t n = 0;
3540  for (sal_Int32 i = 0, len = s.getLength(); i < len; ++i)
3541  n = 31 * n + s[i];
3542  return n;
3543  }
3544  else
3545  return std::size_t(s.hashCode());
3546  }
3547 };
3548 
3549 }
3550 
3551 #endif
3552 
3554 #endif /* _RTL_USTRING_HXX */
3555 
3556 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SAL_WARN_UNUSED_RESULT OUString replaceAll(OUString const &from, OUString const &to, sal_Int32 fromIndex=0) const
Returns a new string resulting from replacing all occurrences of a given substring with another subst...
Definition: ustring.hxx:2491
#define OUSTRING_TO_OSTRING_CVTFLAGS
Definition: string.h:1358
SAL_DLLPUBLIC sal_Int32 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const char *second, sal_Int32 shortenedLen) SAL_THROW_EXTERN_C()
Compare two strings with a maximum count of characters, ignoring the case of ASCII characters...
sal_Int32 getLength() const
Returns the length of this string.
Definition: string.hxx:637
SAL_WARN_UNUSED_RESULT OUString concat(const OUString &str) const
Concatenates the specified string to the end of this string.
Definition: ustring.hxx:2224
OString OUStringToOString(const OUString &rUnicode, rtl_TextEncoding encoding, sal_uInt32 convertFlags=OUSTRING_TO_OSTRING_CVTFLAGS)
Convert an OUString to an OString, using a specific text encoding.
Definition: ustring.hxx:3472
sal_uInt64 toUInt64(sal_Int16 radix=10) const
Returns the uint64 value from this string.
Definition: ustring.hxx:2794
libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type reverseCompareTo(T &literal) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:929
SAL_WARN_UNUSED_RESULT OUString copy(sal_Int32 beginIndex) const
Returns a new string that is a substring of this string.
Definition: ustring.hxx:2151
OUString()
New string containing no characters.
Definition: ustring.hxx:212
sal_Int32 getLength() const
Returns the length of this string.
Definition: ustring.hxx:804
#define RTL_TEXTENCODING_UTF8
Definition: textenc.h:117
SAL_DLLPUBLIC void rtl_uString_newReplaceAllFromIndex(rtl_uString **newStr, rtl_uString *str, rtl_uString const *from, rtl_uString const *to, sal_Int32 fromIndex) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a given substring with another substring...
SAL_DLLPUBLIC void rtl_uString_intern(rtl_uString **newStr, rtl_uString *str) SAL_THROW_EXTERN_C()
Return a canonical representation for a string.
#define RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
Definition: textcvt.h:68
SAL_DLLPUBLIC void rtl_uString_newTrim(rtl_uString **newStr, rtl_uString *str) SAL_THROW_EXTERN_C()
Create a new string by removing white space from both ends of another string.
OUString OStringToOUString(const OString &rStr, rtl_TextEncoding encoding, sal_uInt32 convertFlags=OSTRING_TO_OUSTRING_CVTFLAGS)
Convert an OString to an OUString, using a specific text encoding.
Definition: ustring.hxx:3439
static OUString number(unsigned long long ll, sal_Int16 radix=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: ustring.hxx:3116
SAL_DLLPUBLIC void rtl_uString_newReplaceFirstToAsciiL(rtl_uString **newStr, rtl_uString *str, rtl_uString const *from, char const *to, sal_Int32 toLength, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf(T &literal, sal_Int32 fromIndex=0) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1993
sal_Int32 indexOf(const OUString &str, sal_Int32 fromIndex=0) const
Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.
Definition: ustring.hxx:1979
SAL_DLLPUBLIC void rtl_uString_newToAsciiUpperCase(rtl_uString **newStr, rtl_uString *str) SAL_THROW_EXTERN_C()
Create a new string by converting all ASCII lowercase letters to uppercase within another string...
double toDouble() const
Returns the double value from this string.
Definition: ustring.hxx:2820
sal_Unicode toChar() const
Returns the first character from this string.
Definition: ustring.hxx:2730
bool matchIgnoreAsciiCase(const OUString &str, sal_Int32 fromIndex=0) const
Match against a substring appearing in this string, ignoring the case of ASCII letters.
Definition: ustring.hxx:1122
SAL_DLLPUBLIC sal_Int32 rtl_ustr_lastIndexOfChar_WithLength(const sal_Unicode *str, sal_Int32 len, sal_Unicode ch) SAL_THROW_EXTERN_C()
Search for the last occurrence of a character within a string.
bool equalsAscii(const char *asciiStr) const
Perform a comparison of two strings.
Definition: ustring.hxx:1235
std::basic_ostream< charT, traits > & operator<<(std::basic_ostream< charT, traits > &stream, OString const &rString)
Support for rtl::OString in std::ostream (and thus in CPPUNIT_ASSERT or SAL_INFO macros, for example).
Definition: string.hxx:2325
SAL_DLLPUBLIC void rtl_string2UString(rtl_uString **newStr, const char *str, sal_Int32 len, rtl_TextEncoding encoding, sal_uInt32 convertFlags) SAL_THROW_EXTERN_C()
Create a new Unicode string by converting a byte string, using a specific text encoding.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_compare_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const sal_Unicode *second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
Compare two strings.
const char * getStr() const SAL_RETURNS_NONNULL
Returns a pointer to the characters of this string.
Definition: string.hxx:663
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase(T &literal, sal_Int32 fromIndex=0) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1136
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(T &literal, OUString *rest=NULL) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1449
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type match(T &literal, sal_Int32 fromIndex=0) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1082
#define RTL_USTR_MAX_VALUEOFFLOAT
Definition: ustring.h:1026
bool startsWith(OUString const &str, OUString *rest=NULL) const
Check whether this string starts with a given substring.
Definition: ustring.hxx:1434
static OUString const & unacquired(rtl_uString *const *ppHandle)
Provides an OUString const & passing a storage pointer of an rtl_uString * handle.
Definition: ustring.hxx:540
#define RTL_USTR_MAX_VALUEOFUINT64
Definition: ustring.h:1007
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase(T &literal) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1031
SAL_DLLPUBLIC void rtl_uString_newReplaceFirstAsciiLAsciiL(rtl_uString **newStr, rtl_uString *str, char const *from, sal_Int32 fromLength, char const *to, sal_Int32 toLength, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
friend OUString operator+(const OUString &rStr1, const OUString &rStr2)
Definition: ustring.hxx:2233
sal_Int32 reverseCompareToAsciiL(const char *asciiStr, sal_Int32 asciiStrLength) const
Compares two strings in reverse order.
Definition: ustring.hxx:1214
static OUString fromUtf8(const OString &rSource)
Convert an OString to an OUString, assuming that the OString is UTF-8-encoded.
Definition: ustring.hxx:3002
SAL_DLLPUBLIC void rtl_uString_internConvert(rtl_uString **newStr, const char *str, sal_Int32 len, rtl_TextEncoding encoding, sal_uInt32 convertFlags, sal_uInt32 *pInfo) SAL_THROW_EXTERN_C()
Return a canonical representation for a string.
sal_uInt32 iterateCodePoints(sal_Int32 *indexUtf16, sal_Int32 incrementCodePoints=1) const
Iterate through this string based on code points instead of UTF-16 code units.
Definition: ustring.hxx:2972
SAL_DLLPUBLIC void rtl_uString_newReplaceStrAt(rtl_uString **newStr, rtl_uString *str, sal_Int32 idx, sal_Int32 count, rtl_uString *subStr) SAL_THROW_EXTERN_C()
Create a new string by replacing a substring of another string.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_compareIgnoreAsciiCase_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const sal_Unicode *second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
Compare two strings, ignoring the case of ASCII characters.
static OUString number(unsigned int i, sal_Int16 radix=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: ustring.hxx:3091
A string buffer implements a mutable sequence of characters.
Definition: ustrbuf.hxx:71
SAL_DLLPUBLIC sal_Int32 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const char *second) SAL_THROW_EXTERN_C()
Compare two strings, ignoring the case of ASCII characters.
bool operator!=(const Any &rAny, const C &value)
Template inequality operator: compares set value of left side any to right side value.
Definition: Any.hxx:673
const sal_Unicode * getStr() const SAL_RETURNS_NONNULL
Returns a pointer to the Unicode character buffer for this string.
Definition: ustring.hxx:826
bool operator<(const TTimeValue &rTimeA, const TTimeValue &rTimeB)
Definition: timer.hxx:93
friend libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==(const OUString &rString, T &literal)
Compare string to an ASCII string literal.
Definition: ustring.hxx:1791
SAL_DLLPUBLIC void rtl_uString_newReplaceAllAsciiL(rtl_uString **newStr, rtl_uString *str, char const *from, sal_Int32 fromLength, rtl_uString const *to) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a given substring with another substring...
SAL_DLLPUBLIC void rtl_uString_newToAsciiLowerCase(rtl_uString **newStr, rtl_uString *str) SAL_THROW_EXTERN_C()
Create a new string by converting all ASCII uppercase letters to lowercase within another string...
SAL_DLLPUBLIC sal_Bool rtl_ustr_asciil_reverseEquals_WithLength(const sal_Unicode *first, const char *second, sal_Int32 len) SAL_THROW_EXTERN_C()
Compare two strings from back to front for equality.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_valueOfBoolean(sal_Unicode *str, sal_Bool b) SAL_THROW_EXTERN_C()
Create the string representation of a boolean.
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWithIgnoreAsciiCase(T &literal, OUString *rest=NULL) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1516
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type endsWithIgnoreAsciiCase(T &literal, OUString *rest=NULL) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1668
bool operator>(const TTimeValue &rTimeA, const TTimeValue &rTimeB)
Definition: timer.hxx:103
bool equalsAsciiL(const char *asciiStr, sal_Int32 asciiStrLength) const
Perform a comparison of two strings.
Definition: ustring.hxx:1257
SAL_DLLPUBLIC sal_Int32 rtl_ustr_shortenedCompare_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const sal_Unicode *second, sal_Int32 secondLen, sal_Int32 shortenedLen) SAL_THROW_EXTERN_C()
Compare two strings with a maximum count of characters.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_lastIndexOfStr_WithLength(const sal_Unicode *str, sal_Int32 len, const sal_Unicode *subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
Search for the last occurrence of a substring within a string.
SAL_DLLPUBLIC sal_Bool rtl_convertStringToUString(rtl_uString **target, char const *source, sal_Int32 length, rtl_TextEncoding encoding, sal_uInt32 flags) SAL_THROW_EXTERN_C()
Converts a byte string to a Unicode string, signalling failure.
bool operator==(const TTimeValue &rTimeA, const TTimeValue &rTimeB)
Definition: timer.hxx:113
SAL_DLLPUBLIC sal_uInt64 rtl_ustr_toUInt64(const sal_Unicode *str, sal_Int16 radix) SAL_THROW_EXTERN_C()
Interpret a string as an unsigned long integer.
Definition: stringutils.hxx:140
#define SAL_DEPRECATED(message)
Use as follows: SAL_DEPRECATED("Don&#39;t use, it&#39;s evil.") void doit(int nPara);.
Definition: types.h:474
sal_Int32 compareTo(const OUString &str) const
Compares two strings.
Definition: ustring.hxx:862
#define SAL_WARN_UNUSED
Annotate classes where a compiler should warn if an instance is unused.
Definition: types.h:587
SAL_DLLPUBLIC sal_Int32 rtl_ustr_toInt32(const sal_Unicode *str, sal_Int16 radix) SAL_THROW_EXTERN_C()
Interpret a string as an integer.
static OUString intern(const char *value, sal_Int32 length, rtl_TextEncoding encoding, sal_uInt32 convertFlags=OSTRING_TO_OUSTRING_CVTFLAGS, sal_uInt32 *pInfo=NULL)
Return a canonical representation for a converted string.
Definition: ustring.hxx:2876
sal_Int32 lastIndexOf(const OUString &str, sal_Int32 fromIndex) const
Returns the index within this string of the last occurrence of the specified substring, searching backward starting before the specified index.
Definition: ustring.hxx:2093
SAL_DLLPUBLIC void rtl_uString_newConcatUtf16L(rtl_uString **newString, rtl_uString *left, sal_Unicode const *right, sal_Int32 rightLength)
Create a new string that is the concatenation of two other strings.
SAL_WARN_UNUSED_RESULT libreoffice_internal::ConstCharArrayDetector< T1, typename libreoffice_internal::ConstCharArrayDetector< T2, OUString >::Type >::Type replaceAll(T1 &from, T2 &to) const
Returns a new string resulting from replacing all occurrences of a given substring with another subst...
Definition: ustring.hxx:2594
sal_Int32 compareToIgnoreAsciiCase(const OUString &str) const
Perform an ASCII lowercase comparison of two strings.
Definition: ustring.hxx:1018
SAL_DLLPUBLIC void rtl_uString_assign(rtl_uString **str, rtl_uString *rightValue) SAL_THROW_EXTERN_C()
Assign a new value to a string.
SAL_DLLPUBLIC float rtl_ustr_toFloat(const sal_Unicode *str) SAL_THROW_EXTERN_C()
Interpret a string as a float.
SAL_DLLPUBLIC void rtl_uString_acquire(rtl_uString *str) SAL_THROW_EXTERN_C() SAL_HOT
Increment the reference count of a string.
OUString getToken(sal_Int32 token, sal_Unicode cTok, sal_Int32 &index) const
Returns a token in the string.
Definition: ustring.hxx:2686
bool convertToString(OString *pTarget, rtl_TextEncoding nEncoding, sal_uInt32 nFlags) const
Converts to an OString, signalling failure.
Definition: ustring.hxx:2914
#define RTL_USTR_MAX_VALUEOFDOUBLE
Definition: ustring.h:1045
SAL_DLLPUBLIC void rtl_uString_newFromAscii(rtl_uString **newStr, const char *value) SAL_THROW_EXTERN_C()
Allocate a new string that contains a copy of a character array.
SAL_WARN_UNUSED_RESULT OUString toAsciiLowerCase() const
Converts from this string all ASCII uppercase characters (65-90) to ASCII lowercase characters (97-12...
Definition: ustring.hxx:2618
SAL_DLLPUBLIC sal_uInt32 rtl_ustr_toUInt32(const sal_Unicode *str, sal_Int16 radix) SAL_THROW_EXTERN_C()
Interpret a string as an unsigned integer.
sal_Int32 toInt32(sal_Int16 radix=10) const
Returns the int32 value from this string.
Definition: ustring.hxx:2745
#define RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR
Definition: textcvt.h:151
SAL_WARN_UNUSED_RESULT OUString copy(sal_Int32 beginIndex, sal_Int32 count) const
Returns a new string that is a substring of this string.
Definition: ustring.hxx:2168
SAL_DLLPUBLIC void rtl_uString_newFromStr_WithLength(rtl_uString **newStr, const sal_Unicode *value, sal_Int32 len) SAL_THROW_EXTERN_C()
Allocate a new string that contains a copy of a character array.
SAL_WARN_UNUSED_RESULT libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceAll(OUString const &from, T &to) const
Returns a new string resulting from replacing all occurrences of a given substring with another subst...
Definition: ustring.hxx:2567
sal_uInt16 sal_Unicode
Definition: types.h:123
SAL_DLLPUBLIC void rtl_uString_newConcat(rtl_uString **newStr, rtl_uString *left, rtl_uString *right) SAL_THROW_EXTERN_C()
Create a new string that is the concatenation of two other strings.
SAL_DLLPUBLIC void rtl_uString_newFromLiteral(rtl_uString **newStr, const char *value, sal_Int32 len, sal_Int32 allocExtra) SAL_THROW_EXTERN_C()
unsigned char sal_Bool
Definition: types.h:38
static OUString createFromAscii(const char *value)
Returns an OUString copied without conversion from an ASCII character string.
Definition: ustring.hxx:3271
sal_Int32 compareTo(const OUString &str, sal_Int32 maxLength) const
Compares two strings with a maximum count of characters.
Definition: ustring.hxx:891
SAL_WARN_UNUSED_RESULT OUString toAsciiUpperCase() const
Converts from this string all ASCII lowercase characters (97-122) to ASCII uppercase characters (65-9...
Definition: ustring.hxx:2635
__sal_NoAcquire
Definition: types.h:352
SAL_DLLPUBLIC void rtl_uString_release(rtl_uString *str) SAL_THROW_EXTERN_C() SAL_HOT
Decrement the reference count of a string.
sal_Int32 indexOfAsciiL(char const *str, sal_Int32 len, sal_Int32 fromIndex=0) const
Returns the index within this string of the first occurrence of the specified ASCII substring...
Definition: ustring.hxx:2027
A helper to use OUStrings with hash maps.
Definition: ustring.hxx:3397
static OUString number(float f)
Returns the string representation of the float argument.
Definition: ustring.hxx:3131
sal_Int32 compareToAscii(const char *asciiStr) const
Compares two strings.
Definition: ustring.hxx:1161
SAL_DLLPUBLIC void rtl_uString_new(rtl_uString **newStr) SAL_THROW_EXTERN_C()
Allocate a new string containing no characters.
#define OSTRING_TO_OUSTRING_CVTFLAGS
Definition: ustring.h:2187
SAL_DLLPUBLIC sal_Bool rtl_ustr_toBoolean(const sal_Unicode *str) SAL_THROW_EXTERN_C()
Interpret a string as a boolean.
#define RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR
Definition: textcvt.h:75
SAL_WARN_UNUSED_RESULT libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceAll(T &from, OUString const &to) const
Returns a new string resulting from replacing all occurrences of a given substring with another subst...
Definition: ustring.hxx:2527
bool equalsIgnoreAsciiCaseAscii(const char *asciiStr) const
Perform an ASCII lowercase comparison of two strings.
Definition: ustring.hxx:1284
sal_Int32 indexOf(sal_Unicode ch, sal_Int32 fromIndex=0) const
Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
Definition: ustring.hxx:1920
SAL_DLLPUBLIC void rtl_uString_ensureCapacity(rtl_uString **str, sal_Int32 size) SAL_THROW_EXTERN_C()
Ensure a string has enough space for a given number of characters.
SAL_DLLPUBLIC rtl_uString * rtl_uString_alloc(sal_Int32 nLen) SAL_THROW_EXTERN_C()
Allocate a new string containing space for a given number of characters.
OUString(rtl_uString *str)
New string from OUString data.
Definition: ustring.hxx:249
SAL_DLLPUBLIC sal_Int32 rtl_ustr_hashCode_WithLength(const sal_Unicode *str, sal_Int32 len) SAL_THROW_EXTERN_C()
Return a hash code for a string.
libreoffice_internal::ConstCharArrayDetector< T, bool >::Type endsWith(T &literal, OUString *rest=NULL) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:1578
SAL_DLLPUBLIC void rtl_uString_newReplaceFirstAsciiL(rtl_uString **newStr, rtl_uString *str, char const *from, sal_Int32 fromLength, rtl_uString const *to, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
sal_uInt16 rtl_TextEncoding
The various supported text encodings.
Definition: textenc.h:37
SAL_DLLPUBLIC sal_Int32 rtl_uString_getToken(rtl_uString **newStr, rtl_uString *str, sal_Int32 token, sal_Unicode cTok, sal_Int32 idx) SAL_THROW_EXTERN_C()
Create a new string by extracting a single token from another string.
bool matchAsciiL(const char *asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex=0) const
Match against a substring appearing in this string.
Definition: ustring.hxx:1359
#define RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
Definition: textcvt.h:145
SAL_DLLPUBLIC sal_Int64 rtl_ustr_toInt64(const sal_Unicode *str, sal_Int16 radix) SAL_THROW_EXTERN_C()
Interpret a string as a long integer.
Definition: bootstrap.hxx:33
SAL_WARN_UNUSED_RESULT OUString replace(sal_Unicode oldChar, sal_Unicode newChar) const
Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar...
Definition: ustring.hxx:2284
SAL_DLLPUBLIC void rtl_uString_newReplace(rtl_uString **newStr, rtl_uString *str, sal_Unicode oldChar, sal_Unicode newChar) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a single character within another string...
bool equalsIgnoreAsciiCase(const OUString &str) const
Perform an ASCII lowercase comparison of two strings.
Definition: ustring.hxx:986
bool match(const OUString &str, sal_Int32 fromIndex=0) const
Match against a substring appearing in this string.
Definition: ustring.hxx:1069
SAL_WARN_UNUSED_RESULT libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst(OUString const &from, T &to, sal_Int32 *index=NULL) const
Returns a new string resulting from replacing the first occurrence of a given substring with another ...
Definition: ustring.hxx:2415
SAL_DLLPUBLIC sal_Int32 rtl_ustr_asciil_reverseCompare_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const char *second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
Compare two strings from back to front.
SAL_DLLPUBLIC sal_uInt32 rtl_uString_iterateCodePoints(rtl_uString const *string, sal_Int32 *indexUtf16, sal_Int32 incrementCodePoints)
Iterate through a string based on code points instead of UTF-16 code units.
friend libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=(const OUString &rString, T &literal)
Compare string to an ASCII string literal.
Definition: ustring.hxx:1823
sal_uInt32 toUInt32(sal_Int16 radix=10) const
Returns the uint32 value from this string.
Definition: ustring.hxx:2762
SAL_DLLPUBLIC void rtl_uString_newConcatAsciiL(rtl_uString **newString, rtl_uString *left, char const *right, sal_Int32 rightLength)
Create a new string that is the concatenation of two other strings.
bool equals(const OUString &str) const
Perform a comparison of two strings.
Definition: ustring.hxx:950
SAL_DLLPUBLIC sal_Int32 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(sal_Unicode const *first, sal_Int32 firstLen, char const *second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
Compare two strings, ignoring the case of ASCII characters.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_ascii_compare_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const char *second) SAL_THROW_EXTERN_C()
Compare two strings.
bool matchIgnoreAsciiCaseAsciiL(const char *asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex=0) const
Match against a substring appearing in this string, ignoring the case of ASCII letters.
Definition: ustring.hxx:1396
static OUString number(int i, sal_Int16 radix=10)
Returns the string representation of the integer argument.
Definition: ustring.hxx:3084
SAL_DLLPUBLIC sal_Int32 rtl_ustr_indexOfStr_WithLength(const sal_Unicode *str, sal_Int32 len, const sal_Unicode *subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
Search for the first occurrence of a substring within a string.
OUString & operator+=(const OUString &str)
Append a string to this string.
Definition: ustring.hxx:675
This String class provide base functionality for C++ like 8-Bit character array handling.
Definition: string.hxx:215
This String class provides base functionality for C++ like Unicode character array handling...
Definition: ustring.hxx:202
libreoffice_internal::ConstCharArrayDetector< T, OUString &>::Type operator=(T &literal)
Assign a new string from an 8-Bit string literal that is expected to contain only characters in the A...
Definition: ustring.hxx:597
definition of a no acquire enum for ctors
Definition: types.h:356
~OUString()
Release the string data.
Definition: ustring.hxx:524
OString toUtf8() const
Convert this string to an OString, assuming that the string can be UTF-8-encoded successfully.
Definition: ustring.hxx:3026
OUString(const char *value, sal_Int32 length, rtl_TextEncoding encoding, sal_uInt32 convertFlags=OSTRING_TO_OUSTRING_CVTFLAGS)
New string from an 8-Bit character buffer array.
Definition: ustring.hxx:446
SAL_WARN_UNUSED_RESULT libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst(T &from, OUString const &to, sal_Int32 *index=NULL) const
Returns a new string resulting from replacing the first occurrence of a given substring with another ...
Definition: ustring.hxx:2366
sal_Int32 lastIndexOf(const OUString &str) const
Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the end.
Definition: ustring.hxx:2064
bool endsWithAsciiL(char const *asciiStr, sal_Int32 asciiStrLength) const
Check whether this string ends with a given ASCII string.
Definition: ustring.hxx:1611
SAL_DLLPUBLIC sal_Int32 rtl_ustr_lastIndexOfAscii_WithLength(sal_Unicode const *str, sal_Int32 len, char const *subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
Search for the last occurrence of an ASCII substring within a string.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_valueOfInt32(sal_Unicode *str, sal_Int32 i, sal_Int16 radix) SAL_THROW_EXTERN_C()
Create the string representation of an integer.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const sal_Unicode *second, sal_Int32 secondLen, sal_Int32 shortenedLen) SAL_THROW_EXTERN_C()
Compare two strings with a maximum count of characters, ignoring the case of ASCII characters...
OUString(rtl_uString *str, __sal_NoAcquire)
New OUString from OUString data without acquiring it.
Definition: ustring.hxx:263
SAL_DLLPUBLIC void rtl_uString_newReplaceAllUtf16LAsciiL(rtl_uString **newStr, rtl_uString *str, sal_Unicode const *from, sal_Int32 fromLength, char const *to, sal_Int32 toLength) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a given substring with another substring...
static OUString boolean(bool b)
Returns the string representation of the boolean argument.
Definition: ustring.hxx:3180
SAL_DLLPUBLIC void rtl_uString_newReplaceAllAsciiLAsciiL(rtl_uString **newStr, rtl_uString *str, char const *from, sal_Int32 fromLength, char const *to, sal_Int32 toLength) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a given substring with another substring...
SAL_DLLPUBLIC sal_Int32 rtl_ustr_indexOfChar_WithLength(const sal_Unicode *str, sal_Int32 len, sal_Unicode ch) SAL_THROW_EXTERN_C()
Search for the first occurrence of a character within a string.
OUString(const sal_Unicode *value)
New string from a Unicode character buffer array.
Definition: ustring.hxx:312
SAL_DLLPUBLIC void rtl_uString_newReplaceFirst(rtl_uString **newStr, rtl_uString *str, rtl_uString const *from, rtl_uString const *to, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
sal_Int32 oslInterlockedCount
Definition: interlck.h:44
SAL_DLLPUBLIC void rtl_uString_newReplaceFirstUtf16LAsciiL(rtl_uString **newStr, rtl_uString *str, sal_Unicode const *from, sal_Int32 fromLength, char const *to, sal_Int32 toLength, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
SAL_DLLPUBLIC sal_Int32 rtl_ustr_getLength(const sal_Unicode *str) SAL_THROW_EXTERN_C()
Return the length of a string.
sal_Int32 lastIndexOf(sal_Unicode ch) const
Returns the index within this string of the last occurrence of the specified character, searching backward starting at the end.
Definition: ustring.hxx:1935
OUString(const OUString &str)
New string from OUString.
Definition: ustring.hxx:223
Definition: stringutils.hxx:142
sal_Int32 lastIndexOfAsciiL(char const *str, sal_Int32 len) const
Returns the index within this string of the last occurrence of the specified ASCII substring...
Definition: ustring.hxx:2135
SAL_DLLPUBLIC void rtl_uString_newFromStr(rtl_uString **newStr, const sal_Unicode *value) SAL_THROW_EXTERN_C()
Allocate a new string that contains a copy of a character array.
SAL_DLLPUBLIC sal_Int32 rtl_ustr_valueOfInt64(sal_Unicode *str, sal_Int64 l, sal_Int16 radix) SAL_THROW_EXTERN_C()
Create the string representation of a long integer.
SAL_WARN_UNUSED_RESULT OUString replaceAt(sal_Int32 index, sal_Int32 count, const OUString &newStr) const
Returns a new string resulting from replacing n = count characters from position index in this string...
Definition: ustring.hxx:2254
bool equalsIgnoreAsciiCaseAsciiL(const char *asciiStr, sal_Int32 asciiStrLength) const
Perform an ASCII lowercase comparison of two strings.
Definition: ustring.hxx:1331
SAL_DLLPUBLIC sal_Int32 rtl_ustr_reverseCompare_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const sal_Unicode *second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
Compare two strings from back to front.
bool isEmpty() const
Checks if a string is empty.
Definition: ustring.hxx:814
SAL_DLLPUBLIC void rtl_uString_newReplaceFirstAsciiLUtf16L(rtl_uString **newStr, rtl_uString *str, char const *from, sal_Int32 fromLength, sal_Unicode const *to, sal_Int32 toLength, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
SAL_WARN_UNUSED_RESULT OUString trim() const
Returns a new string resulting from removing white space from both ends of the string.
Definition: ustring.hxx:2655
bool startsWithIgnoreAsciiCase(OUString const &str, OUString *rest=NULL) const
Check whether this string starts with a given string, ignoring the case of ASCII letters.
Definition: ustring.hxx:1498
#define SAL_WARN_UNUSED_RESULT
Use this as markup for functions and methods whose return value must be checked.
Definition: types.h:284
sal_Int64 toInt64(sal_Int16 radix=10) const
Returns the int64 value from this string.
Definition: ustring.hxx:2777
OUString(const sal_Unicode *value, sal_Int32 length)
New string from a Unicode character buffer array.
Definition: ustring.hxx:328
SAL_DLLPUBLIC void rtl_uString_newFromCodePoints(rtl_uString **newString, sal_uInt32 const *codePoints, sal_Int32 codePointCount) SAL_THROW_EXTERN_C()
Allocate a new string from an array of Unicode code points.
OUString & operator=(const OUString &str)
Assign a new string.
Definition: ustring.hxx:564
#define RTL_USTR_MAX_VALUEOFBOOLEAN
Definition: ustring.h:919
SAL_DLLPUBLIC sal_Int32 rtl_ustr_valueOfFloat(sal_Unicode *str, float f) SAL_THROW_EXTERN_C()
Create the string representation of a float.
SAL_DLLPUBLIC void rtl_uString_newFromSubString(rtl_uString **newStr, const rtl_uString *from, sal_Int32 beginIndex, sal_Int32 count) SAL_THROW_EXTERN_C()
Allocate a new string that is a substring of this string.
OUString(T &literal, typename libreoffice_internal::ConstCharArrayDetector< T, libreoffice_internal::Dummy >::Type=libreoffice_internal::Dummy())
New string from an 8-Bit string literal that is expected to contain only characters in the ASCII set ...
Definition: ustring.hxx:350
SAL_DLLPUBLIC sal_Int32 rtl_ustr_ascii_shortenedCompare_WithLength(const sal_Unicode *first, sal_Int32 firstLen, const char *second, sal_Int32 shortenedLen) SAL_THROW_EXTERN_C()
Compare two strings with a maximum count of characters.
size_t operator()(const OUString &rString) const
Compute a hash code for a string.
Definition: ustring.hxx:3408
SAL_WARN_UNUSED_RESULT libreoffice_internal::ConstCharArrayDetector< T1, typename libreoffice_internal::ConstCharArrayDetector< T2, OUString >::Type >::Type replaceFirst(T1 &from, T2 &to, sal_Int32 *index=NULL) const
Returns a new string resulting from replacing the first occurrence of a given substring with another ...
Definition: ustring.hxx:2450
sal_Int32 compareToIgnoreAsciiCaseAscii(const char *asciiStr) const
Compares two ASCII strings ignoring case.
Definition: ustring.hxx:1307
SAL_DLLPUBLIC void rtl_uString_newReplaceAllAsciiLUtf16L(rtl_uString **newStr, rtl_uString *str, char const *from, sal_Int32 fromLength, sal_Unicode const *to, sal_Int32 toLength) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a given substring with another substring...
libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf(T &literal) const
This is an overloaded member function, provided for convenience. It differs from the above function ...
Definition: ustring.hxx:2106
SAL_DLLPUBLIC void rtl_uString_newReplaceFirstUtf16LUtf16L(rtl_uString **newStr, rtl_uString *str, sal_Unicode const *from, sal_Int32 fromLength, sal_Unicode const *to, sal_Int32 toLength, sal_Int32 *index) SAL_THROW_EXTERN_C()
Create a new string by replacing the first occurrence of a given substring with another substring...
SAL_DLLPUBLIC sal_Int32 rtl_ustr_indexOfAscii_WithLength(sal_Unicode const *str, sal_Int32 len, char const *subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
Search for the first occurrence of an ASCII substring within a string.
bool endsWithIgnoreAsciiCase(OUString const &str, OUString *rest=NULL) const
Check whether this string ends with a given string, ignoring the case of ASCII letters.
Definition: ustring.hxx:1650
static OUString number(long long ll, sal_Int16 radix=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: ustring.hxx:3109
friend libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==(T &literal, const OUString &rString)
Compare string to an ASCII string literal.
Definition: ustring.hxx:1807
bool endsWith(OUString const &str, OUString *rest=NULL) const
Check whether this string ends with a given substring.
Definition: ustring.hxx:1561
#define RTL_USTR_MAX_VALUEOFINT32
Definition: ustring.h:961
SAL_DLLPUBLIC double rtl_ustr_toDouble(const sal_Unicode *str) SAL_THROW_EXTERN_C()
Interpret a string as a double.
SAL_DLLPUBLIC void rtl_uString_newReplaceAllToAsciiL(rtl_uString **newStr, rtl_uString *str, rtl_uString const *from, char const *to, sal_Int32 toLength) SAL_THROW_EXTERN_C()
Create a new string by replacing all occurrences of a given substring with another substring...
float toFloat() const
Returns the float value from this string.
Definition: ustring.hxx:2807
void clear()
Clears the string, i.e, makes a zero-character string.
Definition: ustring.hxx:791
#define RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
Definition: textcvt.h:72
SAL_DLLPUBLIC sal_Int32 rtl_ustr_valueOfUInt64(sal_Unicode *str, sal_uInt64 l, sal_Int16 radix) SAL_THROW_EXTERN_C()
Create the string representation of an unsigned long integer.
OUString intern() const
Return a canonical representation for a string.
Definition: ustring.hxx:2841
static OUString number(long i, sal_Int16 radix=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: ustring.hxx:3097
#define RTL_USTR_MAX_VALUEOFINT64
Definition: ustring.h:984
static OUString number(double d)
Returns the string representation of the double argument.
Definition: ustring.hxx:3146
friend libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=(T &literal, const OUString &rString)
Compare string to an ASCII string literal.
Definition: ustring.hxx:1839
OUString(sal_uInt32 const *codePoints, sal_Int32 codePointCount)
Create a new string from an array of Unicode code points.
Definition: ustring.hxx:473
SAL_WARN_UNUSED_RESULT OUString replaceFirst(OUString const &from, OUString const &to, sal_Int32 *index=NULL) const
Returns a new string resulting from replacing the first occurrence of a given substring with another ...
Definition: ustring.hxx:2321
static OUString number(unsigned long i, sal_Int16 radix=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: ustring.hxx:3103
OUString getToken(sal_Int32 count, sal_Unicode separator) const
Returns a token from the string.
Definition: ustring.hxx:2706
sal_Int32 reverseCompareTo(const OUString &str) const
Compares two strings in reverse order.
Definition: ustring.hxx:916
OUString(sal_Unicode value)
New string from a single Unicode character.
Definition: ustring.hxx:271
sal_Int32 lastIndexOf(sal_Unicode ch, sal_Int32 fromIndex) const
Returns the index within this string of the last occurrence of the specified character, searching backward starting before the specified index.
Definition: ustring.hxx:1952
bool endsWithIgnoreAsciiCaseAsciiL(char const *asciiStr, sal_Int32 asciiStrLength) const
Check whether this string ends with a given ASCII string, ignoring the case of ASCII letters...
Definition: ustring.hxx:1702
SAL_DLLPUBLIC sal_Int32 rtl_ustr_valueOfDouble(sal_Unicode *str, double d) SAL_THROW_EXTERN_C()
Create the string representation of a double.
bool toBoolean() const
Returns the Boolean value from this string.
Definition: ustring.hxx:2719
SAL_DLLPUBLIC sal_Bool rtl_convertUStringToString(rtl_String **pTarget, sal_Unicode const *pSource, sal_Int32 nLength, rtl_TextEncoding nEncoding, sal_uInt32 nFlags) SAL_THROW_EXTERN_C()
Converts a Unicode string to a byte string, signalling failure.
sal_Int32 hashCode() const
Returns a hashcode for this string.
Definition: ustring.hxx:1902