LCOV - code coverage report
Current view: top level - include/rtl - string.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 87 276 31.5 %
Date: 2014-04-14 Functions: 40 436 9.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #ifndef INCLUDED_RTL_STRING_HXX
      21             : #define INCLUDED_RTL_STRING_HXX
      22             : 
      23             : #include <sal/config.h>
      24             : 
      25             : #include <cassert>
      26             : #include <new>
      27             : #include <ostream>
      28             : #include <string.h>
      29             : 
      30             : #include <osl/diagnose.h>
      31             : #include <rtl/textenc.h>
      32             : #include <rtl/string.h>
      33             : #include <rtl/stringutils.hxx>
      34             : 
      35             : #ifdef RTL_FAST_STRING
      36             : #include <rtl/stringconcat.hxx>
      37             : #endif
      38             : 
      39             : #include <sal/log.hxx>
      40             : 
      41             : // The unittest uses slightly different code to help check that the proper
      42             : // calls are made. The class is put into a different namespace to make
      43             : // sure the compiler generates a different (if generating also non-inline)
      44             : // copy of the function and does not merge them together. The class
      45             : // is "brought" into the proper rtl namespace by a typedef below.
      46             : #ifdef RTL_STRING_UNITTEST
      47             : #define rtl rtlunittest
      48             : #endif
      49             : 
      50             : namespace rtl
      51             : {
      52             : 
      53             : /// @cond INTERNAL
      54             : #ifdef RTL_STRING_UNITTEST
      55             : #undef rtl
      56             : // helper macro to make functions appear more readable
      57             : #define RTL_STRING_CONST_FUNCTION rtl_string_unittest_const_literal_function = true;
      58             : #else
      59             : #define RTL_STRING_CONST_FUNCTION
      60             : #endif
      61             : /// @endcond
      62             : 
      63             : /* ======================================================================= */
      64             : 
      65             : /**
      66             :   This String class provide base functionality for C++ like 8-Bit
      67             :   character array handling. The advantage of this class is, that it
      68             :   handle all the memory managament for you - and it do it
      69             :   more efficient. If you assign a string to another string, the
      70             :   data of both strings are shared (without any copy operation or
      71             :   memory allocation) as long as you do not change the string. This class
      72             :   stores also the length of the string, so that many operations are
      73             :   faster as the C-str-functions.
      74             : 
      75             :   This class provide only readonly string handling. So you could create
      76             :   a string and you could only query the content from this string.
      77             :   It provide also functionality to change the string, but this results
      78             :   in every case in a new string instance (in the most cases with an
      79             :   memory allocation). You don't have functionality to change the
      80             :   content of the string. If you want change the string content, than
      81             :   you should us the OStringBuffer class, which provide these
      82             :   functionality and avoid to much memory allocation.
      83             : 
      84             :   The design of this class is similar to the string classes in Java
      85             :   and so more people should have fewer understanding problems when they
      86             :   use this class.
      87             : */
      88             : 
      89             : class SAL_WARN_UNUSED OString
      90             : {
      91             : public:
      92             :     /// @cond INTERNAL
      93             :     rtl_String * pData;
      94             :     /// @endcond
      95             : 
      96             :     /**
      97             :       New string containing no characters.
      98             :     */
      99      382658 :     OString() SAL_THROW(())
     100             :     {
     101      382658 :         pData = 0;
     102      382658 :         rtl_string_new( &pData );
     103      382658 :     }
     104             : 
     105             :     /**
     106             :       New string from OString.
     107             : 
     108             :       @param    str         a OString.
     109             :     */
     110      255028 :     OString( const OString & str ) SAL_THROW(())
     111             :     {
     112      255028 :         pData = str.pData;
     113      255028 :         rtl_string_acquire( pData );
     114      255028 :     }
     115             : 
     116             :     /**
     117             :       New string from OString data.
     118             : 
     119             :       @param    str         a OString data.
     120             :     */
     121           2 :     OString( rtl_String * str ) SAL_THROW(())
     122             :     {
     123           2 :         pData = str;
     124           2 :         rtl_string_acquire( pData );
     125           2 :     }
     126             : 
     127             :     /** New string from OString data without acquiring it.  Takeover of ownership.
     128             : 
     129             :         The SAL_NO_ACQUIRE dummy parameter is only there to distinguish this
     130             :         from other constructors.
     131             : 
     132             :       @param    str         a OString data.
     133             :     */
     134     6976582 :     inline OString( rtl_String * str, __sal_NoAcquire ) SAL_THROW(())
     135             :     {
     136     6976582 :         pData = str;
     137     6976582 :     }
     138             : 
     139             :     /**
     140             :       New string from a single character.
     141             : 
     142             :       @param    value       a character.
     143             :     */
     144           0 :     explicit OString( sal_Char value ) SAL_THROW(())
     145           0 :         : pData (0)
     146             :     {
     147           0 :         rtl_string_newFromStr_WithLength( &pData, &value, 1 );
     148           0 :     }
     149             : 
     150             :     /**
     151             :       New string from a character buffer array.
     152             : 
     153             :       Note: The argument type is always either char* or const char*. The template is
     154             :       used only for technical reasons, as is the second argument.
     155             : 
     156             :       @param    value       a NULL-terminated character array.
     157             :     */
     158             :     template< typename T >
     159      680108 :     OString( const T& value, typename internal::CharPtrDetector< T, internal::Dummy >::Type = internal::Dummy() ) SAL_THROW(())
     160             :     {
     161      680108 :         pData = 0;
     162      680108 :         rtl_string_newFromStr( &pData, value );
     163      680108 :     }
     164             : 
     165             :     template< typename T >
     166           0 :     OString( T& value, typename internal::NonConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy() ) SAL_THROW(())
     167             :     {
     168           0 :         pData = 0;
     169           0 :         rtl_string_newFromStr( &pData, value );
     170           0 :     }
     171             : 
     172             :     /**
     173             :       New string from a string literal.
     174             : 
     175             :       If there are any embedded \0's in the string literal, the result is undefined.
     176             :       Use the overload that explicitly accepts length.
     177             : 
     178             :       @since LibreOffice 3.6
     179             : 
     180             :       @param    literal       a string literal
     181             :     */
     182             :     template< typename T >
     183      637590 :     OString( T& literal, typename internal::ConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy() ) SAL_THROW(())
     184             :     {
     185             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     186      637590 :         pData = 0;
     187             :         if( internal::ConstCharArrayDetector< T, void >::size - 1 == 0 ) // empty string
     188           0 :             rtl_string_new( &pData );
     189             :         else
     190      637590 :             rtl_string_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
     191             : #ifdef RTL_STRING_UNITTEST
     192             :         rtl_string_unittest_const_literal = true;
     193             : #endif
     194      637590 :     }
     195             : 
     196             :     /**
     197             :       New string from a character buffer array.
     198             : 
     199             :       @param    value       a character array.
     200             :       @param    length      the number of character which should be copied.
     201             :                             The character array length must be greater or
     202             :                             equal than this value.
     203             :     */
     204     3535260 :     OString( const sal_Char * value, sal_Int32 length ) SAL_THROW(())
     205             :     {
     206     3535260 :         pData = 0;
     207     3535260 :         rtl_string_newFromStr_WithLength( &pData, value, length );
     208     3535260 :     }
     209             : 
     210             :     /**
     211             :       New string from a Unicode character buffer array.
     212             : 
     213             :       @param    value           a Unicode character array.
     214             :       @param    length          the number of character which should be converted.
     215             :                                 The Unicode character array length must be
     216             :                                 greater or equal than this value.
     217             :       @param    encoding        the text encoding in which the Unicode character
     218             :                                 sequence should be converted.
     219             :       @param    convertFlags    flags which controls the conversion.
     220             :                                 see RTL_UNICODETOTEXT_FLAGS_...
     221             : 
     222             :       @exception std::bad_alloc is thrown if an out-of-memory condition occurs
     223             :     */
     224     1872179 :     OString( const sal_Unicode * value, sal_Int32 length,
     225             :              rtl_TextEncoding encoding,
     226             :              sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
     227             :     {
     228     1872179 :         pData = 0;
     229     1872179 :         rtl_uString2String( &pData, value, length, encoding, convertFlags );
     230     1872179 :         if (pData == 0) {
     231           0 :             throw std::bad_alloc();
     232             :         }
     233     1872179 :     }
     234             : 
     235             : #ifdef RTL_FAST_STRING
     236             :     /**
     237             :      @overload
     238             :      @internal
     239             :     */
     240             :     template< typename T1, typename T2 >
     241           6 :     OString( const OStringConcat< T1, T2 >& c )
     242             :     {
     243           6 :         const sal_Int32 l = c.length();
     244           6 :         pData = rtl_string_alloc( l );
     245           6 :         if (l != 0)
     246             :         {
     247           6 :             char* end = c.addData( pData->buffer );
     248           6 :             pData->length = end - pData->buffer;
     249           6 :             *end = '\0';
     250             :         }
     251           6 :     }
     252             : #endif
     253             : 
     254             :     /**
     255             :       Release the string data.
     256             :     */
     257    14339413 :     ~OString() SAL_THROW(())
     258             :     {
     259    14339413 :         rtl_string_release( pData );
     260    14339413 :     }
     261             : 
     262             :     /**
     263             :       Assign a new string.
     264             : 
     265             :       @param    str         a OString.
     266             :     */
     267      382550 :     OString & operator=( const OString & str ) SAL_THROW(())
     268             :     {
     269      382550 :         rtl_string_assign( &pData, str.pData );
     270      382550 :         return *this;
     271             :     }
     272             : 
     273             :     /**
     274             :      @overload
     275             :      This function accepts an ASCII string literal as its argument.
     276             :      @since LibreOffice 3.6
     277             :     */
     278             :     template< typename T >
     279           0 :     typename internal::ConstCharArrayDetector< T, OString& >::Type operator=( T& literal ) SAL_THROW(())
     280             :     {
     281             :         RTL_STRING_CONST_FUNCTION
     282             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     283             :         if( internal::ConstCharArrayDetector< T, void >::size - 1 == 0 ) // empty string
     284           0 :             rtl_string_new( &pData );
     285             :         else
     286           0 :             rtl_string_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
     287           0 :         return *this;
     288             :     }
     289             : 
     290             :     /**
     291             :       Append a string to this string.
     292             : 
     293             :       @param    str         a OString.
     294             :     */
     295        7244 :     OString & operator+=( const OString & str ) SAL_THROW(())
     296             :     {
     297        7244 :         rtl_string_newConcat( &pData, pData, str.pData );
     298        7244 :         return *this;
     299             :     }
     300             : 
     301             : #ifdef RTL_FAST_STRING
     302             :     /**
     303             :      @overload
     304             :      @internal
     305             :     */
     306             :     template< typename T1, typename T2 >
     307           0 :     OString& operator+=( const OStringConcat< T1, T2 >& c )
     308             :     {
     309           0 :         const int l = c.length();
     310           0 :         if( l == 0 )
     311           0 :             return *this;
     312           0 :         rtl_string_ensureCapacity( &pData, pData->length + l );
     313           0 :         char* end = c.addData( pData->buffer + pData->length );
     314           0 :         *end = '\0';
     315           0 :         pData->length = end - pData->buffer;
     316           0 :         return *this;
     317             :     }
     318             : #endif
     319             :     /**
     320             :       Returns the length of this string.
     321             : 
     322             :       The length is equal to the number of characters in this string.
     323             : 
     324             :       @return   the length of the sequence of characters represented by this
     325             :                 object.
     326             :     */
     327     5799948 :     sal_Int32 getLength() const SAL_THROW(()) { return pData->length; }
     328             : 
     329             :     /**
     330             :       Checks if a string is empty.
     331             : 
     332             :       @return   true if the string is empty;
     333             :                 false, otherwise.
     334             : 
     335             :       @since LibreOffice 3.4
     336             :     */
     337       90467 :     bool isEmpty() const SAL_THROW(())
     338             :     {
     339       90467 :         return pData->length == 0;
     340             :     }
     341             : 
     342             :     /**
     343             :       Returns a pointer to the characters of this string.
     344             : 
     345             :       <p>The returned pointer is guaranteed to point to a null-terminated byte
     346             :       string.  But note that this string object may contain embedded null
     347             :       characters, which will thus also be embedded in the returned
     348             :       null-terminated byte string.</p>
     349             : 
     350             :       @return a pointer to a null-terminated byte string representing the
     351             :       characters of this string object.
     352             :     */
     353     7256964 :     const sal_Char * getStr() const SAL_THROW(()) { return pData->buffer; }
     354             : 
     355             :     /**
     356             :       Access to individual characters.
     357             : 
     358             :       @param index must be non-negative and less than length.
     359             : 
     360             :       @return the character at the given index.
     361             : 
     362             :       @since LibreOffice 3.5
     363             :     */
     364       27141 :     sal_Char operator [](sal_Int32 index) const {
     365             :         // silence spurious -Werror=strict-overflow warnings from GCC 4.8.2
     366             :         assert(index >= 0 && static_cast<sal_uInt32>(index) < static_cast<sal_uInt32>(getLength()));
     367       27141 :         return getStr()[index];
     368             :     }
     369             : 
     370             :     /**
     371             :       Compares two strings.
     372             : 
     373             :       The comparison is based on the numeric value of each character in
     374             :       the strings and return a value indicating their relationship.
     375             :       This function can't be used for language specific sorting.
     376             : 
     377             :       @param    str         the object to be compared.
     378             :       @return   0 - if both strings are equal
     379             :                 < 0 - if this string is less than the string argument
     380             :                 > 0 - if this string is greater than the string argument
     381             :     */
     382           0 :     sal_Int32 compareTo( const OString & str ) const SAL_THROW(())
     383             :     {
     384             :         return rtl_str_compare_WithLength( pData->buffer, pData->length,
     385           0 :                                            str.pData->buffer, str.pData->length );
     386             :     }
     387             : 
     388             :     /**
     389             :       Compares two strings with an maximum count of characters.
     390             : 
     391             :       The comparison is based on the numeric value of each character in
     392             :       the strings and return a value indicating their relationship.
     393             :       This function can't be used for language specific sorting.
     394             : 
     395             :       @param    rObj        the object to be compared.
     396             :       @param    maxLength   the maximum count of characters to be compared.
     397             :       @return   0 - if both strings are equal
     398             :                 < 0 - if this string is less than the string argument
     399             :                 > 0 - if this string is greater than the string argument
     400             :     */
     401           0 :     sal_Int32 compareTo( const OString & rObj, sal_Int32 maxLength ) const SAL_THROW(())
     402             :     {
     403             :         return rtl_str_shortenedCompare_WithLength( pData->buffer, pData->length,
     404           0 :                                                     rObj.pData->buffer, rObj.pData->length, maxLength );
     405             :     }
     406             : 
     407             :     /**
     408             :       Compares two strings in reverse order.
     409             : 
     410             :       The comparison is based on the numeric value of each character in
     411             :       the strings and return a value indicating their relationship.
     412             :       This function can't be used for language specific sorting.
     413             : 
     414             :       @param    str         the object to be compared.
     415             :       @return   0 - if both strings are equal
     416             :                 < 0 - if this string is less than the string argument
     417             :                 > 0 - if this string is greater than the string argument
     418             :     */
     419             :     sal_Int32 reverseCompareTo( const OString & str ) const SAL_THROW(())
     420             :     {
     421             :         return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length,
     422             :                                                   str.pData->buffer, str.pData->length );
     423             :     }
     424             : 
     425             :     /**
     426             :       Perform a comparison of two strings.
     427             : 
     428             :       The result is true if and only if second string
     429             :       represents the same sequence of characters as the first string.
     430             :       This function can't be used for language specific comparison.
     431             : 
     432             :       @param    str         the object to be compared.
     433             :       @return   true if the strings are equal;
     434             :                 false, otherwise.
     435             :     */
     436       42504 :     bool equals( const OString & str ) const SAL_THROW(())
     437             :     {
     438       42504 :         if ( pData->length != str.pData->length )
     439           0 :             return false;
     440       42504 :         if ( pData == str.pData )
     441           0 :             return true;
     442             :         return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length,
     443       42504 :                                                   str.pData->buffer, str.pData->length ) == 0;
     444             :     }
     445             : 
     446             :     /**
     447             :       Perform a comparison of two strings.
     448             : 
     449             :       The result is true if and only if second string
     450             :       represents the same sequence of characters as the first string.
     451             :       The ASCII string must be NULL-terminated and must be greater or
     452             :       equal as length.
     453             :       This function can't be used for language specific comparison.
     454             : 
     455             : 
     456             :       @param    value       a character array.
     457             :       @param    length      the length of the character array.
     458             :       @return   true if the strings are equal;
     459             :                 false, otherwise.
     460             :     */
     461           0 :     bool equalsL( const sal_Char* value, sal_Int32 length ) const SAL_THROW(())
     462             :     {
     463           0 :         if ( pData->length != length )
     464           0 :             return false;
     465             : 
     466             :         return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length,
     467           0 :                                                   value, length ) == 0;
     468             :     }
     469             : 
     470             :     /**
     471             :       Perform a ASCII lowercase comparison of two strings.
     472             : 
     473             :       The result is true if and only if second string
     474             :       represents the same sequence of characters as the first string,
     475             :       ignoring the case.
     476             :       Character values between 65 and 90 (ASCII A-Z) are interpreted as
     477             :       values between 97 and 122 (ASCII a-z).
     478             :       This function can't be used for language specific comparison.
     479             : 
     480             :       @param    str         the object to be compared.
     481             :       @return   true if the strings are equal;
     482             :                 false, otherwise.
     483             :     */
     484           0 :     bool equalsIgnoreAsciiCase( const OString & str ) const SAL_THROW(())
     485             :     {
     486           0 :         if ( pData->length != str.pData->length )
     487           0 :             return false;
     488           0 :         if ( pData == str.pData )
     489           0 :             return true;
     490             :         return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
     491           0 :                                                           str.pData->buffer, str.pData->length ) == 0;
     492             :     }
     493             : 
     494             :     /**
     495             :       Perform a ASCII lowercase comparison of two strings.
     496             : 
     497             :       The result is true if and only if second string
     498             :       represents the same sequence of characters as the first string,
     499             :       ignoring the case.
     500             :       Character values between 65 and 90 (ASCII A-Z) are interpreted as
     501             :       values between 97 and 122 (ASCII a-z).
     502             :       Since this method is optimized for performance, the ASCII character
     503             :       values are not converted in any way. The caller has to make sure that
     504             :       all ASCII characters are in the allowed range between 0 and
     505             :       127. The ASCII string must be NULL-terminated.
     506             :       This function can't be used for language specific comparison.
     507             : 
     508             :       Note: The argument type is always either char* or const char*, the return type is bool.
     509             :       The template is used only for technical reasons.
     510             : 
     511             :       @param    asciiStr        the 8-Bit ASCII character string to be compared.
     512             :       @return   true if the strings are equal;
     513             :                 false, otherwise.
     514             :     */
     515             :     template< typename T >
     516           0 :     typename internal::CharPtrDetector< T, bool >::Type equalsIgnoreAsciiCase( const T& asciiStr ) const SAL_THROW(())
     517             :     {
     518           0 :         return rtl_str_compareIgnoreAsciiCase( pData->buffer, asciiStr ) == 0;
     519             :     }
     520             : 
     521             :     template< typename T >
     522             :     typename internal::NonConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase( T& asciiStr ) const SAL_THROW(())
     523             :     {
     524             :         return rtl_str_compareIgnoreAsciiCase( pData->buffer, asciiStr ) == 0;
     525             :     }
     526             : 
     527             :     /**
     528             :      @overload
     529             :      This function accepts an ASCII string literal as its argument.
     530             :      @since LibreOffice 3.6
     531             :     */
     532             :     template< typename T >
     533           0 :     typename internal::ConstCharArrayDetector< T, bool >::Type  equalsIgnoreAsciiCase( T& literal ) const SAL_THROW(())
     534             :     {
     535             :         RTL_STRING_CONST_FUNCTION
     536             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     537           0 :         if ( pData->length != internal::ConstCharArrayDetector< T, void >::size - 1 )
     538           0 :             return false;
     539             :         return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
     540           0 :                                                           literal, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     541             :     }
     542             : 
     543             :     /**
     544             :       Perform a ASCII lowercase comparison of two strings.
     545             : 
     546             :       The result is true if and only if second string
     547             :       represents the same sequence of characters as the first string,
     548             :       ignoring the case.
     549             :       Character values between 65 and 90 (ASCII A-Z) are interpreted as
     550             :       values between 97 and 122 (ASCII a-z).
     551             :       Since this method is optimized for performance, the ASCII character
     552             :       values are not converted in any way. The caller has to make sure that
     553             :       all ASCII characters are in the allowed range between 0 and
     554             :       127. The ASCII string must be greater or equal in length as asciiStrLength.
     555             :       This function can't be used for language specific comparison.
     556             : 
     557             :       @param    asciiStr        the 8-Bit ASCII character string to be compared.
     558             :       @param    asciiStrLength  the length of the ascii string
     559             :       @return   true if the strings are equal;
     560             :                 false, otherwise.
     561             :     */
     562             :     bool equalsIgnoreAsciiCaseL( const sal_Char * asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(())
     563             :     {
     564             :         if ( pData->length != asciiStrLength )
     565             :             return false;
     566             : 
     567             :         return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
     568             :                                                           asciiStr, asciiStrLength ) == 0;
     569             :     }
     570             : 
     571             :     /**
     572             :       Match against a substring appearing in this string.
     573             : 
     574             :       The result is true if and only if the second string appears as a substring
     575             :       of this string, at the given position.
     576             :       This function can't be used for language specific comparison.
     577             : 
     578             :       @param    str         the object (substring) to be compared.
     579             :       @param    fromIndex   the index to start the comparion from.
     580             :                             The index must be greater or equal than 0
     581             :                             and less or equal as the string length.
     582             :       @return   true if str match with the characters in the string
     583             :                 at the given position;
     584             :                 false, otherwise.
     585             :     */
     586           0 :     bool match( const OString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     587             :     {
     588           0 :         return rtl_str_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
     589           0 :                                                     str.pData->buffer, str.pData->length, str.pData->length ) == 0;
     590             :     }
     591             : 
     592             :     /**
     593             :      @overload
     594             :      This function accepts an ASCII string literal as its argument.
     595             :      @since LibreOffice 3.6
     596             :     */
     597             :     template< typename T >
     598           0 :     typename internal::ConstCharArrayDetector< T, bool >::Type  match( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     599             :     {
     600             :         RTL_STRING_CONST_FUNCTION
     601             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     602             :         return rtl_str_shortenedCompare_WithLength(
     603           0 :             pData->buffer + fromIndex, pData->length - fromIndex,
     604           0 :             literal, internal::ConstCharArrayDetector< T, void >::size - 1, internal::ConstCharArrayDetector< T, void >::size - 1) == 0;
     605             :     }
     606             : 
     607             :     /**
     608             :       Match against a substring appearing in this string.
     609             : 
     610             :       @param str  the substring to be compared; must not be null and must point
     611             :       to memory of at least strLength bytes
     612             : 
     613             :       @param strLength  the length of the substring; must be non-negative
     614             : 
     615             :       @param fromIndex  the index into this string to start the comparison at;
     616             :       must be non-negative and not greater than this string's length
     617             : 
     618             :       @return true if and only if the given str is contained as a substring of
     619             :       this string at the given fromIndex
     620             : 
     621             :       @since LibreOffice 3.6
     622             :     */
     623             :     bool matchL(
     624             :         char const * str, sal_Int32 strLength, sal_Int32 fromIndex = 0)
     625             :         const
     626             :     {
     627             :         return rtl_str_shortenedCompare_WithLength(
     628             :             pData->buffer + fromIndex, pData->length - fromIndex,
     629             :             str, strLength, strLength) == 0;
     630             :     }
     631             : 
     632             :     // This overload is left undefined, to detect calls of matchL that
     633             :     // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
     634             :     // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
     635             :     // platforms):
     636             : #if SAL_TYPES_SIZEOFLONG == 8
     637             :     void matchL(char const *, sal_Int32, rtl_TextEncoding) const;
     638             : #endif
     639             : 
     640             :     /**
     641             :       Match against a substring appearing in this string, ignoring the case of
     642             :       ASCII letters.
     643             : 
     644             :       The result is true if and only if the second string appears as a substring
     645             :       of this string, at the given position.
     646             :       Character values between 65 and 90 (ASCII A-Z) are interpreted as
     647             :       values between 97 and 122 (ASCII a-z).
     648             :       This function can't be used for language specific comparison.
     649             : 
     650             :       @param    str         the object (substring) to be compared.
     651             :       @param    fromIndex   the index to start the comparion from.
     652             :                             The index must be greater or equal than 0
     653             :                             and less or equal as the string length.
     654             :       @return   true if str match with the characters in the string
     655             :                 at the given position;
     656             :                 false, otherwise.
     657             :     */
     658           0 :     bool matchIgnoreAsciiCase( const OString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     659             :     {
     660           0 :         return rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
     661             :                                                                    str.pData->buffer, str.pData->length,
     662           0 :                                                                    str.pData->length ) == 0;
     663             :     }
     664             : 
     665             :     /**
     666             :      @overload
     667             :      This function accepts an ASCII string literal as its argument.
     668             :      @since LibreOffice 3.6
     669             :     */
     670             :     template< typename T >
     671           0 :     typename internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const
     672             :     {
     673             :         RTL_STRING_CONST_FUNCTION
     674             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     675           0 :         return rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
     676           0 :             literal, internal::ConstCharArrayDetector< T, void >::size - 1, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     677             :     }
     678             : 
     679             :     /**
     680             :       Check whether this string starts with a given substring.
     681             : 
     682             :       @param str the substring to be compared
     683             : 
     684             :       @param rest if non-null, and this function returns true, then assign a
     685             :       copy of the remainder of this string to *rest. Available since
     686             :       LibreOffice 4.2
     687             : 
     688             :       @return true if and only if the given str appears as a substring at the
     689             :       start of this string
     690             : 
     691             :       @since LibreOffice 4.0
     692             :     */
     693           0 :     bool startsWith(OString const & str, OString * rest = 0) const {
     694           0 :         bool b = match(str, 0);
     695           0 :         if (b && rest != 0) {
     696           0 :             *rest = copy(str.getLength());
     697             :         }
     698           0 :         return b;
     699             :     }
     700             : 
     701             :     /**
     702             :      @overload
     703             :      This function accepts an ASCII string literal as its argument.
     704             :      @since LibreOffice 4.0
     705             :     */
     706             :     template< typename T >
     707           0 :     typename internal::ConstCharArrayDetector< T, bool >::Type startsWith(
     708             :         T & literal, OString * rest = 0) const
     709             :     {
     710             :         RTL_STRING_CONST_FUNCTION
     711           0 :         bool b = match(literal, 0);
     712           0 :         if (b && rest != 0) {
     713           0 :             *rest = copy(internal::ConstCharArrayDetector< T, void >::size - 1);
     714             :         }
     715           0 :         return b;
     716             :     }
     717             : 
     718             :     /**
     719             :       Check whether this string ends with a given substring.
     720             : 
     721             :       @param str the substring to be compared
     722             : 
     723             :       @param rest if non-null, and this function returns true, then assign a
     724             :       copy of the remainder of this string to *rest. Available since
     725             :       LibreOffice 4.2
     726             : 
     727             :       @return true if and only if the given str appears as a substring at the
     728             :       end of this string
     729             : 
     730             :       @since LibreOffice 3.6
     731             :     */
     732           0 :     bool endsWith(OString const & str, OString * rest = 0) const {
     733           0 :         bool b = str.getLength() <= getLength()
     734           0 :             && match(str, getLength() - str.getLength());
     735           0 :         if (b && rest != 0) {
     736           0 :             *rest = copy(0, getLength() - str.getLength());
     737             :         }
     738           0 :         return b;
     739             :     }
     740             : 
     741             :     /**
     742             :      @overload
     743             :      This function accepts an ASCII string literal as its argument.
     744             :      @since LibreOffice 3.6
     745             :     */
     746             :     template< typename T >
     747           0 :     typename internal::ConstCharArrayDetector< T, bool >::Type endsWith(
     748             :         T & literal, OString * rest = 0) const
     749             :     {
     750             :         RTL_STRING_CONST_FUNCTION
     751             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     752           0 :         bool b = internal::ConstCharArrayDetector< T, void >::size - 1 <= getLength()
     753           0 :             && match(literal, getLength() - ( internal::ConstCharArrayDetector< T, void >::size - 1 ));
     754           0 :         if (b && rest != 0) {
     755           0 :             *rest = copy(
     756             :                 0,
     757           0 :                 (getLength()
     758             :                  - (internal::ConstCharArrayDetector< T, void >::size - 1)));
     759             :         }
     760           0 :         return b;
     761             :     }
     762             : 
     763             :     /**
     764             :       Check whether this string ends with a given substring.
     765             : 
     766             :       @param str  the substring to be compared; must not be null and must point
     767             :       to memory of at least strLength bytes
     768             : 
     769             :       @param strLength  the length of the substring; must be non-negative
     770             : 
     771             :       @return true if and only if the given str appears as a substring at the
     772             :       end of this string
     773             : 
     774             :       @since LibreOffice 3.6
     775             :     */
     776             :     bool endsWithL(char const * str, sal_Int32 strLength) const {
     777             :         return strLength <= getLength()
     778             :             && matchL(str, strLength, getLength() - strLength);
     779             :     }
     780             : 
     781           0 :     friend bool     operator == ( const OString& rStr1, const OString& rStr2 ) SAL_THROW(())
     782           0 :                         { return rStr1.equals(rStr2); }
     783           0 :     friend bool     operator != ( const OString& rStr1,     const OString& rStr2 ) SAL_THROW(())
     784           0 :                         { return !(operator == ( rStr1, rStr2 )); }
     785           0 :     friend bool     operator <  ( const OString& rStr1,    const OString& rStr2 ) SAL_THROW(())
     786           0 :                         { return rStr1.compareTo( rStr2 ) < 0; }
     787             :     friend bool     operator >  ( const OString& rStr1,    const OString& rStr2 ) SAL_THROW(())
     788             :                         { return rStr1.compareTo( rStr2 ) > 0; }
     789             :     friend bool     operator <= ( const OString& rStr1,    const OString& rStr2 ) SAL_THROW(())
     790             :                         { return rStr1.compareTo( rStr2 ) <= 0; }
     791             :     friend bool     operator >= ( const OString& rStr1,    const OString& rStr2 ) SAL_THROW(())
     792             :                         { return rStr1.compareTo( rStr2 ) >= 0; }
     793             : 
     794             :     template< typename T >
     795           0 :     friend typename internal::CharPtrDetector< T, bool >::Type operator==( const OString& rStr1, const T& value ) SAL_THROW(())
     796             :     {
     797           0 :         return rStr1.compareTo( value ) == 0;
     798             :     }
     799             : 
     800             :     template< typename T >
     801             :     friend typename internal::NonConstCharArrayDetector< T, bool >::Type operator==( const OString& rStr1, T& value ) SAL_THROW(())
     802             :     {
     803             :         return rStr1.compareTo( value ) == 0;
     804             :     }
     805             : 
     806             :     template< typename T >
     807           0 :     friend typename internal::CharPtrDetector< T, bool >::Type operator==( const T& value, const OString& rStr2 ) SAL_THROW(())
     808             :     {
     809           0 :         return rStr2.compareTo( value ) == 0;
     810             :     }
     811             : 
     812             :     template< typename T >
     813             :     friend typename internal::NonConstCharArrayDetector< T, bool >::Type operator==( T& value, const OString& rStr2 ) SAL_THROW(())
     814             :     {
     815             :         return rStr2.compareTo( value ) == 0;
     816             :     }
     817             : 
     818             :     /**
     819             :      @overload
     820             :      This function accepts an ASCII string literal as its argument.
     821             :      @since LibreOffice 3.6
     822             :     */
     823             :     template< typename T >
     824           2 :     friend typename internal::ConstCharArrayDetector< T, bool >::Type operator==( const OString& rStr, T& literal ) SAL_THROW(())
     825             :     {
     826             :         RTL_STRING_CONST_FUNCTION
     827             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     828           2 :         return rStr.getLength() == internal::ConstCharArrayDetector< T, void >::size - 1
     829             :             && rtl_str_compare_WithLength( rStr.pData->buffer, rStr.pData->length, literal,
     830           2 :                 internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     831             :     }
     832             : 
     833             :     /**
     834             :      @overload
     835             :      This function accepts an ASCII string literal as its argument.
     836             :      @since LibreOffice 3.6
     837             :     */
     838             :     template< typename T >
     839           0 :     friend typename internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OString& rStr ) SAL_THROW(())
     840             :     {
     841             :         RTL_STRING_CONST_FUNCTION
     842             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     843           0 :         return rStr.getLength() == internal::ConstCharArrayDetector< T, void >::size - 1
     844             :             && rtl_str_compare_WithLength( rStr.pData->buffer, rStr.pData->length, literal,
     845           0 :                 internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     846             :     }
     847             : 
     848             :     template< typename T >
     849             :     friend typename internal::CharPtrDetector< T, bool >::Type operator!=( const OString& rStr1, const T& value ) SAL_THROW(())
     850             :     {
     851             :         return !(operator == ( rStr1, value ));
     852             :     }
     853             : 
     854             :     template< typename T >
     855             :     friend typename internal::NonConstCharArrayDetector< T, bool >::Type operator!=( const OString& rStr1, T& value ) SAL_THROW(())
     856             :     {
     857             :         return !(operator == ( rStr1, value ));
     858             :     }
     859             : 
     860             :     template< typename T >
     861             :     friend typename internal::CharPtrDetector< T, bool >::Type operator!=( const T& value,   const OString& rStr2 ) SAL_THROW(())
     862             :     {
     863             :         return !(operator == ( value, rStr2 ));
     864             :     }
     865             : 
     866             :     template< typename T >
     867             :     friend typename internal::NonConstCharArrayDetector< T, bool >::Type operator!=( T& value,   const OString& rStr2 ) SAL_THROW(())
     868             :     {
     869             :         return !(operator == ( value, rStr2 ));
     870             :     }
     871             : 
     872             :     /**
     873             :      @overload
     874             :      This function accepts an ASCII string literal as its argument.
     875             :      @since LibreOffice 3.6
     876             :     */
     877             :     template< typename T >
     878           1 :     friend typename internal::ConstCharArrayDetector< T, bool >::Type operator!=( const OString& rStr, T& literal ) SAL_THROW(())
     879             :     {
     880           1 :         return !( rStr == literal );
     881             :     }
     882             : 
     883             :     /**
     884             :      @overload
     885             :      This function accepts an ASCII string literal as its argument.
     886             :      @since LibreOffice 3.6
     887             :     */
     888             :     template< typename T >
     889             :     friend typename internal::ConstCharArrayDetector< T, bool >::Type operator!=( T& literal, const OString& rStr ) SAL_THROW(())
     890             :     {
     891             :         return !( literal == rStr );
     892             :     }
     893             : 
     894             :     /**
     895             :       Returns a hashcode for this string.
     896             : 
     897             :       @return   a hash code value for this object.
     898             : 
     899             :       @see rtl::OStringHash for convenient use of boost::unordered_map
     900             :     */
     901           0 :     sal_Int32 hashCode() const SAL_THROW(())
     902             :     {
     903           0 :         return rtl_str_hashCode_WithLength( pData->buffer, pData->length );
     904             :     }
     905             : 
     906             :     /**
     907             :       Returns the index within this string of the first occurrence of the
     908             :       specified character, starting the search at the specified index.
     909             : 
     910             :       @param    ch          character to be located.
     911             :       @param    fromIndex   the index to start the search from.
     912             :                             The index must be greater or equal than 0
     913             :                             and less or equal as the string length.
     914             :       @return   the index of the first occurrence of the character in the
     915             :                 character sequence represented by this string that is
     916             :                 greater than or equal to fromIndex, or
     917             :                 -1 if the character does not occur.
     918             :     */
     919     3528019 :     sal_Int32 indexOf( sal_Char ch, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     920             :     {
     921     3528019 :         sal_Int32 ret = rtl_str_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
     922     3528019 :         return (ret < 0 ? ret : ret+fromIndex);
     923             :     }
     924             : 
     925             :     /**
     926             :       Returns the index within this string of the last occurrence of the
     927             :       specified character, searching backward starting at the end.
     928             : 
     929             :       @param    ch          character to be located.
     930             :       @return   the index of the last occurrence of the character in the
     931             :                 character sequence represented by this string, or
     932             :                 -1 if the character does not occur.
     933             :     */
     934           0 :     sal_Int32 lastIndexOf( sal_Char ch ) const SAL_THROW(())
     935             :     {
     936           0 :         return rtl_str_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
     937             :     }
     938             : 
     939             :     /**
     940             :       Returns the index within this string of the last occurrence of the
     941             :       specified character, searching backward starting before the specified
     942             :       index.
     943             : 
     944             :       @param    ch          character to be located.
     945             :       @param    fromIndex   the index before which to start the search.
     946             :       @return   the index of the last occurrence of the character in the
     947             :                 character sequence represented by this string that
     948             :                 is less than fromIndex, or -1
     949             :                 if the character does not occur before that point.
     950             :     */
     951             :     sal_Int32 lastIndexOf( sal_Char ch, sal_Int32 fromIndex ) const SAL_THROW(())
     952             :     {
     953             :         return rtl_str_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
     954             :     }
     955             : 
     956             :     /**
     957             :       Returns the index within this string of the first occurrence of the
     958             :       specified substring, starting at the specified index.
     959             : 
     960             :       If str doesn't include any character, always -1 is
     961             :       returned. This is also the case, if both strings are empty.
     962             : 
     963             :       @param    str         the substring to search for.
     964             :       @param    fromIndex   the index to start the search from.
     965             :       @return   If the string argument occurs one or more times as a substring
     966             :                 within this string at the starting index, then the index
     967             :                 of the first character of the first such substring is
     968             :                 returned. If it does not occur as a substring starting
     969             :                 at fromIndex or beyond, -1 is returned.
     970             :     */
     971           0 :     sal_Int32 indexOf( const OString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     972             :     {
     973           0 :         sal_Int32 ret = rtl_str_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
     974           0 :                                                        str.pData->buffer, str.pData->length );
     975           0 :         return (ret < 0 ? ret : ret+fromIndex);
     976             :     }
     977             : 
     978             :     /**
     979             :      @overload
     980             :      This function accepts an ASCII string literal as its argument.
     981             :      @since LibreOffice 3.6
     982             :     */
     983             :     template< typename T >
     984           0 :     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     985             :     {
     986             :         RTL_STRING_CONST_FUNCTION
     987             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     988             :         sal_Int32 n = rtl_str_indexOfStr_WithLength(
     989           0 :             pData->buffer + fromIndex, pData->length - fromIndex, literal, internal::ConstCharArrayDetector< T, void >::size - 1);
     990           0 :         return n < 0 ? n : n + fromIndex;
     991             :     }
     992             : 
     993             :     /**
     994             :       Returns the index within this string of the first occurrence of the
     995             :       specified substring, starting at the specified index.
     996             : 
     997             :       If str doesn't include any character, always -1 is
     998             :       returned. This is also the case, if both strings are empty.
     999             : 
    1000             :       @param    str         the substring to search for.
    1001             :       @param    len         the length of the substring.
    1002             :       @param    fromIndex   the index to start the search from.
    1003             :       @return   If the string argument occurs one or more times as a substring
    1004             :                 within this string at the starting index, then the index
    1005             :                 of the first character of the first such substring is
    1006             :                 returned. If it does not occur as a substring starting
    1007             :                 at fromIndex or beyond, -1 is returned.
    1008             : 
    1009             :       @since LibreOffice 3.6
    1010             :     */
    1011             :     sal_Int32 indexOfL(char const * str, sal_Int32 len, sal_Int32 fromIndex = 0)
    1012             :         const SAL_THROW(())
    1013             :     {
    1014             :         sal_Int32 n = rtl_str_indexOfStr_WithLength(
    1015             :             pData->buffer + fromIndex, pData->length - fromIndex, str, len);
    1016             :         return n < 0 ? n : n + fromIndex;
    1017             :     }
    1018             : 
    1019             :     // This overload is left undefined, to detect calls of indexOfL that
    1020             :     // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
    1021             :     // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
    1022             :     // platforms):
    1023             : #if SAL_TYPES_SIZEOFLONG == 8
    1024             :     void indexOfL(char const *, sal_Int32, rtl_TextEncoding) const;
    1025             : #endif
    1026             : 
    1027             :     /**
    1028             :       Returns the index within this string of the last occurrence of
    1029             :       the specified substring, searching backward starting at the end.
    1030             : 
    1031             :       The returned index indicates the starting index of the substring
    1032             :       in this string.
    1033             :       If str doesn't include any character, always -1 is
    1034             :       returned. This is also the case, if both strings are empty.
    1035             : 
    1036             :       @param    str         the substring to search for.
    1037             :       @return   If the string argument occurs one or more times as a substring
    1038             :                 within this string, then the index of the first character of
    1039             :                 the last such substring is returned. If it does not occur as
    1040             :                 a substring, -1 is returned.
    1041             :     */
    1042           0 :     sal_Int32 lastIndexOf( const OString & str ) const SAL_THROW(())
    1043             :     {
    1044             :         return rtl_str_lastIndexOfStr_WithLength( pData->buffer, pData->length,
    1045           0 :                                                   str.pData->buffer, str.pData->length );
    1046             :     }
    1047             : 
    1048             :     /**
    1049             :       Returns the index within this string of the last occurrence of
    1050             :       the specified substring, searching backward starting before the specified
    1051             :       index.
    1052             : 
    1053             :       The returned index indicates the starting index of the substring
    1054             :       in this string.
    1055             :       If str doesn't include any character, always -1 is
    1056             :       returned. This is also the case, if both strings are empty.
    1057             : 
    1058             :       @param    str         the substring to search for.
    1059             :       @param    fromIndex   the index before which to start the search.
    1060             :       @return   If the string argument occurs one or more times as a substring
    1061             :                 within this string before the starting index, then the index
    1062             :                 of the first character of the last such substring is
    1063             :                 returned. Otherwise, -1 is returned.
    1064             :     */
    1065             :     sal_Int32 lastIndexOf( const OString & str, sal_Int32 fromIndex ) const SAL_THROW(())
    1066             :     {
    1067             :         return rtl_str_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
    1068             :                                                   str.pData->buffer, str.pData->length );
    1069             :     }
    1070             : 
    1071             :     /**
    1072             :       Returns a new string that is a substring of this string.
    1073             : 
    1074             :       The substring begins at the specified beginIndex. If
    1075             :       beginIndex is negative or be greater than the length of
    1076             :       this string, behaviour is undefined.
    1077             : 
    1078             :       @param     beginIndex   the beginning index, inclusive.
    1079             :       @return    the specified substring.
    1080             :     */
    1081     1742781 :     SAL_WARN_UNUSED_RESULT OString copy( sal_Int32 beginIndex ) const SAL_THROW(())
    1082             :     {
    1083     1742781 :         rtl_String *pNew = 0;
    1084     1742781 :         rtl_string_newFromSubString( &pNew, pData, beginIndex, getLength() - beginIndex );
    1085     1742781 :         return OString( pNew, SAL_NO_ACQUIRE );
    1086             :     }
    1087             : 
    1088             :     /**
    1089             :       Returns a new string that is a substring of this string.
    1090             : 
    1091             :       The substring begins at the specified beginIndex and contains count
    1092             :       characters.  If either beginIndex or count are negative,
    1093             :       or beginIndex + count are greater than the length of this string
    1094             :       then behaviour is undefined.
    1095             : 
    1096             :       @param     beginIndex   the beginning index, inclusive.
    1097             :       @param     count        the number of characters.
    1098             :       @return    the specified substring.
    1099             :     */
    1100     1742783 :     SAL_WARN_UNUSED_RESULT OString copy( sal_Int32 beginIndex, sal_Int32 count ) const SAL_THROW(())
    1101             :     {
    1102     1742783 :         rtl_String *pNew = 0;
    1103     1742783 :         rtl_string_newFromSubString( &pNew, pData, beginIndex, count );
    1104     1742783 :         return OString( pNew, SAL_NO_ACQUIRE );
    1105             :     }
    1106             : 
    1107             :     /**
    1108             :       Concatenates the specified string to the end of this string.
    1109             : 
    1110             :       @param    str   the string that is concatenated to the end
    1111             :                       of this string.
    1112             :       @return   a string that represents the concatenation of this string
    1113             :                 followed by the string argument.
    1114             :     */
    1115           0 :     SAL_WARN_UNUSED_RESULT OString concat( const OString & str ) const SAL_THROW(())
    1116             :     {
    1117           0 :         rtl_String* pNew = 0;
    1118           0 :         rtl_string_newConcat( &pNew, pData, str.pData );
    1119           0 :         return OString( pNew, SAL_NO_ACQUIRE );
    1120             :     }
    1121             : 
    1122             : #ifndef RTL_FAST_STRING
    1123             :     friend OString operator+( const OString & str1, const OString & str2  ) SAL_THROW(())
    1124             :     {
    1125             :         return str1.concat( str2 );
    1126             :     }
    1127             : #endif
    1128             : 
    1129             :     /**
    1130             :       Returns a new string resulting from replacing n = count characters
    1131             :       from position index in this string with newStr.
    1132             : 
    1133             :       @param  index   the replacing index in str.
    1134             :                       The index must be greater or equal as 0 and
    1135             :                       less or equal as the length of the string.
    1136             :       @param  count   the count of characters that will replaced
    1137             :                       The count must be greater or equal as 0 and
    1138             :                       less or equal as the length of the string minus index.
    1139             :       @param  newStr  the new substring.
    1140             :       @return the new string.
    1141             :     */
    1142           0 :     SAL_WARN_UNUSED_RESULT OString replaceAt( sal_Int32 index, sal_Int32 count, const OString& newStr ) const SAL_THROW(())
    1143             :     {
    1144           0 :         rtl_String* pNew = 0;
    1145           0 :         rtl_string_newReplaceStrAt( &pNew, pData, index, count, newStr.pData );
    1146           0 :         return OString( pNew, SAL_NO_ACQUIRE );
    1147             :     }
    1148             : 
    1149             :     /**
    1150             :       Returns a new string resulting from replacing all occurrences of
    1151             :       oldChar in this string with newChar.
    1152             : 
    1153             :       If the character oldChar does not occur in the character sequence
    1154             :       represented by this object, then the string is assigned with
    1155             :       str.
    1156             : 
    1157             :       @param    oldChar     the old character.
    1158             :       @param    newChar     the new character.
    1159             :       @return   a string derived from this string by replacing every
    1160             :                 occurrence of oldChar with newChar.
    1161             :     */
    1162           0 :     SAL_WARN_UNUSED_RESULT OString replace( sal_Char oldChar, sal_Char newChar ) const SAL_THROW(())
    1163             :     {
    1164           0 :         rtl_String* pNew = 0;
    1165           0 :         rtl_string_newReplace( &pNew, pData, oldChar, newChar );
    1166           0 :         return OString( pNew, SAL_NO_ACQUIRE );
    1167             :     }
    1168             : 
    1169             :     /**
    1170             :       Returns a new string resulting from replacing the first occurrence of a
    1171             :       given substring with another substring.
    1172             : 
    1173             :       @param from  the substring to be replaced
    1174             : 
    1175             :       @param to  the replacing substring
    1176             : 
    1177             :       @param[in,out] index  pointer to a start index; if the pointer is
    1178             :       non-null: upon entry to the function, its value is the index into the this
    1179             :       string at which to start searching for the \p from substring, the value
    1180             :       must be non-negative and not greater than this string's length; upon exit
    1181             :       from the function its value is the index into this string at which the
    1182             :       replacement took place or -1 if no replacement took place; if the pointer
    1183             :       is null, searching always starts at index 0
    1184             : 
    1185             :       @since LibreOffice 3.6
    1186             :     */
    1187           0 :     SAL_WARN_UNUSED_RESULT OString replaceFirst(
    1188             :         OString const & from, OString const & to, sal_Int32 * index = 0) const
    1189             :     {
    1190           0 :         rtl_String * s = 0;
    1191           0 :         sal_Int32 i = 0;
    1192             :         rtl_string_newReplaceFirst(
    1193             :             &s, pData, from.pData->buffer, from.pData->length,
    1194           0 :             to.pData->buffer, to.pData->length, index == 0 ? &i : index);
    1195           0 :         return OString(s, SAL_NO_ACQUIRE);
    1196             :     }
    1197             : 
    1198             :     /**
    1199             :       Returns a new string resulting from replacing all occurrences of a given
    1200             :       substring with another substring.
    1201             : 
    1202             :       Replacing subsequent occurrences picks up only after a given replacement.
    1203             :       That is, replacing from "xa" to "xx" in "xaa" results in "xxa", not "xxx".
    1204             : 
    1205             :       @param from  the substring to be replaced
    1206             : 
    1207             :       @param to  the replacing substring
    1208             : 
    1209             :       @since LibreOffice 3.6
    1210             :     */
    1211           0 :     SAL_WARN_UNUSED_RESULT OString replaceAll(OString const & from, OString const & to) const {
    1212           0 :         rtl_String * s = 0;
    1213             :         rtl_string_newReplaceAll(
    1214             :             &s, pData, from.pData->buffer, from.pData->length,
    1215           0 :             to.pData->buffer, to.pData->length);
    1216           0 :         return OString(s, SAL_NO_ACQUIRE);
    1217             :     }
    1218             : 
    1219             :     /**
    1220             :       Converts from this string all ASCII uppercase characters (65-90)
    1221             :       to ASCII lowercase characters (97-122).
    1222             : 
    1223             :       This function can't be used for language specific conversion.
    1224             :       If the string doesn't contain characters which must be converted,
    1225             :       then the new string is assigned with str.
    1226             : 
    1227             :       @return   the string, converted to ASCII lowercase.
    1228             :     */
    1229           0 :     SAL_WARN_UNUSED_RESULT OString toAsciiLowerCase() const SAL_THROW(())
    1230             :     {
    1231           0 :         rtl_String* pNew = 0;
    1232           0 :         rtl_string_newToAsciiLowerCase( &pNew, pData );
    1233           0 :         return OString( pNew, SAL_NO_ACQUIRE );
    1234             :     }
    1235             : 
    1236             :     /**
    1237             :       Converts from this string all ASCII lowercase characters (97-122)
    1238             :       to ASCII uppercase characters (65-90).
    1239             : 
    1240             :       This function can't be used for language specific conversion.
    1241             :       If the string doesn't contain characters which must be converted,
    1242             :       then the new string is assigned with str.
    1243             : 
    1244             :       @return   the string, converted to ASCII uppercase.
    1245             :     */
    1246           0 :     SAL_WARN_UNUSED_RESULT OString toAsciiUpperCase() const SAL_THROW(())
    1247             :     {
    1248           0 :         rtl_String* pNew = 0;
    1249           0 :         rtl_string_newToAsciiUpperCase( &pNew, pData );
    1250           0 :         return OString( pNew, SAL_NO_ACQUIRE );
    1251             :     }
    1252             : 
    1253             :     /**
    1254             :       Returns a new string resulting from removing white space from both ends
    1255             :       of the string.
    1256             : 
    1257             :       All characters that have codes less than or equal to
    1258             :       32 (the space character) are considered to be white space.
    1259             :       If the string doesn't contain white spaces at both ends,
    1260             :       then the new string is assigned with str.
    1261             : 
    1262             :       @return   the string, with white space removed from the front and end.
    1263             :     */
    1264     3485562 :     SAL_WARN_UNUSED_RESULT OString trim() const SAL_THROW(())
    1265             :     {
    1266     3485562 :         rtl_String* pNew = 0;
    1267     3485562 :         rtl_string_newTrim( &pNew, pData );
    1268     3485562 :         return OString( pNew, SAL_NO_ACQUIRE );
    1269             :     }
    1270             : 
    1271             :     /**
    1272             :       Returns a token in the string.
    1273             : 
    1274             :       Example:
    1275             :         sal_Int32 nIndex = 0;
    1276             :         do
    1277             :         {
    1278             :             ...
    1279             :             OString aToken = aStr.getToken( 0, ';', nIndex );
    1280             :             ...
    1281             :         }
    1282             :         while ( nIndex >= 0 );
    1283             : 
    1284             :       @param    token       the number of the token to return.
    1285             :       @param    cTok        the character which separate the tokens.
    1286             :       @param    index       the position at which the token is searched in the
    1287             :                             string.
    1288             :                             The index must not be greater thanthe length of the
    1289             :                             string.
    1290             :                             This param is set to the position of the
    1291             :                             next token or to -1, if it is the last token.
    1292             :       @return   the token; if either token or index is negative, an empty token
    1293             :                 is returned (and index is set to -1)
    1294             :     */
    1295        5456 :     OString getToken( sal_Int32 token, sal_Char cTok, sal_Int32& index ) const SAL_THROW(())
    1296             :     {
    1297        5456 :         rtl_String * pNew = 0;
    1298        5456 :         index = rtl_string_getToken( &pNew, pData, token, cTok, index );
    1299        5456 :         return OString( pNew, SAL_NO_ACQUIRE );
    1300             :     }
    1301             : 
    1302             :     /**
    1303             :       Returns a token from the string.
    1304             : 
    1305             :       The same as getToken(sal_Int32, sal_Char, sal_Int32 &), but always passing
    1306             :       in 0 as the start index in the third argument.
    1307             : 
    1308             :       @param count  the number of the token to return, starting with 0
    1309             :       @param separator  the character which separates the tokens
    1310             : 
    1311             :       @return  the given token, or an empty string
    1312             : 
    1313             :       @since LibreOffice 3.6
    1314             :      */
    1315           0 :     OString getToken(sal_Int32 count, char separator) const {
    1316           0 :         sal_Int32 n = 0;
    1317           0 :         return getToken(count, separator, n);
    1318             :     }
    1319             : 
    1320             :     /**
    1321             :       Returns the Boolean value from this string.
    1322             : 
    1323             :       This function can't be used for language specific conversion.
    1324             : 
    1325             :       @return   true, if the string is 1 or "True" in any ASCII case.
    1326             :                 false in any other case.
    1327             :     */
    1328             :     bool toBoolean() const SAL_THROW(())
    1329             :     {
    1330             :         return rtl_str_toBoolean( pData->buffer );
    1331             :     }
    1332             : 
    1333             :     /**
    1334             :       Returns the first character from this string.
    1335             : 
    1336             :       @return   the first character from this string or 0, if this string
    1337             :                 is emptry.
    1338             :     */
    1339           0 :     sal_Char toChar() const SAL_THROW(())
    1340             :     {
    1341           0 :         return pData->buffer[0];
    1342             :     }
    1343             : 
    1344             :     /**
    1345             :       Returns the int32 value from this string.
    1346             : 
    1347             :       This function can't be used for language specific conversion.
    1348             : 
    1349             :       @param    radix       the radix (between 2 and 36)
    1350             :       @return   the int32 represented from this string.
    1351             :                 0 if this string represents no number or one of too large
    1352             :                 magnitude.
    1353             :     */
    1354        5354 :     sal_Int32 toInt32( sal_Int16 radix = 10 ) const SAL_THROW(())
    1355             :     {
    1356        5354 :         return rtl_str_toInt32( pData->buffer, radix );
    1357             :     }
    1358             : 
    1359             :     /**
    1360             :       Returns the uint32 value from this string.
    1361             : 
    1362             :       This function can't be used for language specific conversion.
    1363             : 
    1364             :       @param    radix       the radix (between 2 and 36)
    1365             :       @return   the uint32 represented from this string.
    1366             :                 0 if this string represents no number or one of too large
    1367             :                 magnitude.
    1368             : 
    1369             :       @since LibreOffice 4.2
    1370             :     */
    1371           0 :     sal_uInt32 toUInt32( sal_Int16 radix = 10 ) const SAL_THROW(())
    1372             :     {
    1373           0 :         return rtl_str_toUInt32( pData->buffer, radix );
    1374             :     }
    1375             : 
    1376             :     /**
    1377             :       Returns the int64 value from this string.
    1378             : 
    1379             :       This function can't be used for language specific conversion.
    1380             : 
    1381             :       @param    radix       the radix (between 2 and 36)
    1382             :       @return   the int64 represented from this string.
    1383             :                 0 if this string represents no number or one of too large
    1384             :                 magnitude.
    1385             :     */
    1386           0 :     sal_Int64 toInt64( sal_Int16 radix = 10 ) const SAL_THROW(())
    1387             :     {
    1388           0 :         return rtl_str_toInt64( pData->buffer, radix );
    1389             :     }
    1390             : 
    1391             :     /**
    1392             :       Returns the uint64 value from this string.
    1393             : 
    1394             :       This function can't be used for language specific conversion.
    1395             : 
    1396             :       @param    radix       the radix (between 2 and 36)
    1397             :       @return   the uint64 represented from this string.
    1398             :                 0 if this string represents no number or one of too large
    1399             :                 magnitude.
    1400             : 
    1401             :       @since LibreOffice 4.1
    1402             :     */
    1403           0 :     sal_uInt64 toUInt64( sal_Int16 radix = 10 ) const SAL_THROW(())
    1404             :     {
    1405           0 :         return rtl_str_toUInt64( pData->buffer, radix );
    1406             :     }
    1407             : 
    1408             :     /**
    1409             :       Returns the float value from this string.
    1410             : 
    1411             :       This function can't be used for language specific conversion.
    1412             : 
    1413             :       @return   the float represented from this string.
    1414             :                 0.0 if this string represents no number.
    1415             :     */
    1416           0 :     float toFloat() const SAL_THROW(())
    1417             :     {
    1418           0 :         return rtl_str_toFloat( pData->buffer );
    1419             :     }
    1420             : 
    1421             :     /**
    1422             :       Returns the double value from this string.
    1423             : 
    1424             :       This function can't be used for language specific conversion.
    1425             : 
    1426             :       @return   the double represented from this string.
    1427             :                 0.0 if this string represents no number.
    1428             :     */
    1429           0 :     double toDouble() const SAL_THROW(())
    1430             :     {
    1431           0 :         return rtl_str_toDouble( pData->buffer );
    1432             :     }
    1433             : 
    1434             :     /**
    1435             :       Returns the string representation of the integer argument.
    1436             : 
    1437             :       This function can't be used for language specific conversion.
    1438             : 
    1439             :       @param    i           an integer value
    1440             :       @param    radix       the radix (between 2 and 36)
    1441             :       @return   a string with the string representation of the argument.
    1442             :       @since LibreOffice 4.1
    1443             :     */
    1444           0 :     static OString number( int i, sal_Int16 radix = 10 )
    1445             :     {
    1446           0 :         return number( static_cast< long long >( i ), radix );
    1447             :     }
    1448             :     /// @overload
    1449             :     /// @since LibreOffice 4.1
    1450           0 :     static OString number( unsigned int i, sal_Int16 radix = 10 )
    1451             :     {
    1452           0 :         return number( static_cast< unsigned long long >( i ), radix );
    1453             :     }
    1454             :     /// @overload
    1455             :     /// @since LibreOffice 4.1
    1456           0 :     static OString number( long i, sal_Int16 radix = 10 )
    1457             :     {
    1458           0 :         return number( static_cast< long long >( i ), radix );
    1459             :     }
    1460             :     /// @overload
    1461             :     /// @since LibreOffice 4.1
    1462           0 :     static OString number( unsigned long i, sal_Int16 radix = 10 )
    1463             :     {
    1464           0 :         return number( static_cast< unsigned long long >( i ), radix );
    1465             :     }
    1466             :     /// @overload
    1467             :     /// @since LibreOffice 4.1
    1468           0 :     static OString number( long long ll, sal_Int16 radix = 10 )
    1469             :     {
    1470             :         sal_Char aBuf[RTL_STR_MAX_VALUEOFINT64];
    1471           0 :         rtl_String* pNewData = 0;
    1472           0 :         rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfInt64( aBuf, ll, radix ) );
    1473           0 :         return OString( pNewData, SAL_NO_ACQUIRE );
    1474             :     }
    1475             :     /// @overload
    1476             :     /// @since LibreOffice 4.1
    1477           0 :     static OString number( unsigned long long ll, sal_Int16 radix = 10 )
    1478             :     {
    1479             :         sal_Char aBuf[RTL_STR_MAX_VALUEOFUINT64];
    1480           0 :         rtl_String* pNewData = 0;
    1481           0 :         rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfUInt64( aBuf, ll, radix ) );
    1482           0 :         return OString( pNewData, SAL_NO_ACQUIRE );
    1483             :     }
    1484             : 
    1485             :     /**
    1486             :       Returns the string representation of the float argument.
    1487             : 
    1488             :       This function can't be used for language specific conversion.
    1489             : 
    1490             :       @param    f           a float.
    1491             :       @return   a string with the string representation of the argument.
    1492             :       @since LibreOffice 4.1
    1493             :     */
    1494           0 :     static OString number( float f )
    1495             :     {
    1496             :         sal_Char aBuf[RTL_STR_MAX_VALUEOFFLOAT];
    1497           0 :         rtl_String* pNewData = 0;
    1498           0 :         rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfFloat( aBuf, f ) );
    1499           0 :         return OString( pNewData, SAL_NO_ACQUIRE );
    1500             :     }
    1501             : 
    1502             :     /**
    1503             :       Returns the string representation of the double argument.
    1504             : 
    1505             :       This function can't be used for language specific conversion.
    1506             : 
    1507             :       @param    d           a double.
    1508             :       @return   a string with the string representation of the argument.
    1509             :       @since LibreOffice 4.1
    1510             :     */
    1511           0 :     static OString number( double d )
    1512             :     {
    1513             :         sal_Char aBuf[RTL_STR_MAX_VALUEOFDOUBLE];
    1514           0 :         rtl_String* pNewData = 0;
    1515           0 :         rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfDouble( aBuf, d ) );
    1516           0 :         return OString( pNewData, SAL_NO_ACQUIRE );
    1517             :     }
    1518             : 
    1519             :     /**
    1520             :       Returns the string representation of the sal_Bool argument.
    1521             : 
    1522             :       If the sal_Bool is true, the string "true" is returned.
    1523             :       If the sal_Bool is false, the string "false" is returned.
    1524             :       This function can't be used for language specific conversion.
    1525             : 
    1526             :       @param    b   a sal_Bool.
    1527             :       @return   a string with the string representation of the argument.
    1528             :       @deprecated use boolean()
    1529             :     */
    1530             :     SAL_DEPRECATED("use boolean()") static OString valueOf( sal_Bool b ) SAL_THROW(())
    1531             :     {
    1532             :         return boolean(b);
    1533             :     }
    1534             : 
    1535             :     /**
    1536             :       Returns the string representation of the boolean argument.
    1537             : 
    1538             :       If the argument is true, the string "true" is returned.
    1539             :       If the argument is false, the string "false" is returned.
    1540             :       This function can't be used for language specific conversion.
    1541             : 
    1542             :       @param    b   a bool.
    1543             :       @return   a string with the string representation of the argument.
    1544             :       @since LibreOffice 4.1
    1545             :     */
    1546           0 :     static OString boolean( bool b ) SAL_THROW(())
    1547             :     {
    1548             :         sal_Char aBuf[RTL_STR_MAX_VALUEOFBOOLEAN];
    1549           0 :         rtl_String* pNewData = 0;
    1550           0 :         rtl_string_newFromStr_WithLength( &pNewData, aBuf, rtl_str_valueOfBoolean( aBuf, b ) );
    1551           0 :         return OString( pNewData, SAL_NO_ACQUIRE );
    1552             :     }
    1553             : 
    1554             :     /**
    1555             :       Returns the string representation of the char argument.
    1556             : 
    1557             :       @param    c   a character.
    1558             :       @return   a string with the string representation of the argument.
    1559             :       @deprecated use operator, function or constructor taking char or sal_Unicode argument
    1560             :     */
    1561             :     SAL_DEPRECATED("convert to OString or use directly") static OString valueOf( sal_Char c ) SAL_THROW(())
    1562             :     {
    1563             :         return OString( &c, 1 );
    1564             :     }
    1565             : 
    1566             :     /**
    1567             :       Returns the string representation of the int argument.
    1568             : 
    1569             :       This function can't be used for language specific conversion.
    1570             : 
    1571             :       @param    i           a int32.
    1572             :       @param    radix       the radix (between 2 and 36)
    1573             :       @return   a string with the string representation of the argument.
    1574             :       @deprecated use number()
    1575             :     */
    1576             :     SAL_DEPRECATED("use number()") static OString valueOf( sal_Int32 i, sal_Int16 radix = 10 ) SAL_THROW(())
    1577             :     {
    1578             :         return number( i, radix );
    1579             :     }
    1580             : 
    1581             :     /**
    1582             :       Returns the string representation of the long argument.
    1583             : 
    1584             :       This function can't be used for language specific conversion.
    1585             : 
    1586             :       @param    ll          a int64.
    1587             :       @param    radix       the radix (between 2 and 36)
    1588             :       @return   a string with the string representation of the argument.
    1589             :       @deprecated use number()
    1590             :     */
    1591             :     SAL_DEPRECATED("use number()") static OString valueOf( sal_Int64 ll, sal_Int16 radix = 10 ) SAL_THROW(())
    1592             :     {
    1593             :         return number( ll, radix );
    1594             :     }
    1595             : 
    1596             :     /**
    1597             :       Returns the string representation of the float argument.
    1598             : 
    1599             :       This function can't be used for language specific conversion.
    1600             : 
    1601             :       @param    f           a float.
    1602             :       @return   a string with the string representation of the argument.
    1603             :       @deprecated use number()
    1604             :     */
    1605             :     SAL_DEPRECATED("use number()") static OString valueOf( float f ) SAL_THROW(())
    1606             :     {
    1607             :         return number(f);
    1608             :     }
    1609             : 
    1610             :     /**
    1611             :       Returns the string representation of the double argument.
    1612             : 
    1613             :       This function can't be used for language specific conversion.
    1614             : 
    1615             :       @param    d           a double.
    1616             :       @return   a string with the string representation of the argument.
    1617             :       @deprecated use number()
    1618             :     */
    1619             :     SAL_DEPRECATED("use number()") static OString valueOf( double d ) SAL_THROW(())
    1620             :     {
    1621             :         return number(d);
    1622             :     }
    1623             : 
    1624             : };
    1625             : 
    1626             : /* ======================================================================= */
    1627             : 
    1628             : #ifdef RTL_FAST_STRING
    1629             : /**
    1630             : A simple wrapper around string literal. It is usually not necessary to use, can
    1631             : be mostly used to force OString operator+ working with operands that otherwise would
    1632             : not trigger it.
    1633             : 
    1634             : This class is not part of public API and is meant to be used only in LibreOffice code.
    1635             : @since LibreOffice 4.0
    1636             : */
    1637             : struct SAL_WARN_UNUSED OStringLiteral
    1638             : {
    1639             :     template< int N >
    1640           0 :     OStringLiteral( const char (&str)[ N ] ) : size( N - 1 ), data( str ) { assert( strlen( str ) == N - 1 ); }
    1641             :     int size;
    1642             :     const char* data;
    1643             : };
    1644             : 
    1645             : /**
    1646             :  @internal
    1647             : */
    1648             : template<>
    1649             : struct ToStringHelper< OString >
    1650             :     {
    1651          18 :     static int length( const OString& s ) { return s.getLength(); }
    1652          18 :     static char* addData( char* buffer, const OString& s ) { return addDataHelper( buffer, s.getStr(), s.getLength()); }
    1653             :     static const bool allowOStringConcat = true;
    1654             :     static const bool allowOUStringConcat = false;
    1655             :     };
    1656             : 
    1657             : /**
    1658             :  @internal
    1659             : */
    1660             : template<>
    1661             : struct ToStringHelper< OStringLiteral >
    1662             :     {
    1663           0 :     static int length( const OStringLiteral& str ) { return str.size; }
    1664           0 :     static char* addData( char* buffer, const OStringLiteral& str ) { return addDataHelper( buffer, str.data, str.size ); }
    1665             :     static const bool allowOStringConcat = true;
    1666             :     static const bool allowOUStringConcat = false;
    1667             :     };
    1668             : 
    1669             : /**
    1670             :  @internal
    1671             : */
    1672             : template< typename charT, typename traits, typename T1, typename T2 >
    1673             : inline std::basic_ostream<charT, traits> & operator <<(
    1674             :     std::basic_ostream<charT, traits> & stream, const OStringConcat< T1, T2 >& concat)
    1675             : {
    1676             :     return stream << OString( concat );
    1677             : }
    1678             : #else
    1679             : // non-RTL_FAST_STRING needs this to compile
    1680             : /// @cond INTERNAL
    1681             : typedef OString OStringLiteral;
    1682             : /// @endcond
    1683             : #endif
    1684             : 
    1685             : 
    1686             : /** A helper to use OStrings with hash maps.
    1687             : 
    1688             :     Instances of this class are unary function objects that can be used as
    1689             :     hash function arguments to boost::unordered_map and similar constructs.
    1690             :  */
    1691             : struct OStringHash
    1692             : {
    1693             :     /** Compute a hash code for a string.
    1694             : 
    1695             :         @param rString
    1696             :         a string.
    1697             : 
    1698             :         @return
    1699             :         a hash code for the string.  This hash code should not be stored
    1700             :         persistently, as its computation may change in later revisions.
    1701             :      */
    1702           0 :     size_t operator()( const OString& rString ) const
    1703           0 :         { return (size_t)rString.hashCode(); }
    1704             : };
    1705             : 
    1706             : /** Equality functor for classic c-strings (i.e., null-terminated char* strings). */
    1707             : struct CStringEqual
    1708             : {
    1709           0 :     bool operator()( const char* p1, const char* p2) const
    1710           0 :         { return rtl_str_compare(p1, p2) == 0; }
    1711             : };
    1712             : 
    1713             : /** Hashing functor for classic c-strings (i.e., null-terminated char* strings). */
    1714             : struct CStringHash
    1715             : {
    1716           0 :     size_t operator()(const char* p) const
    1717           0 :         { return rtl_str_hashCode(p); }
    1718             : };
    1719             : 
    1720             : /* ======================================================================= */
    1721             : 
    1722             : /**
    1723             :     Support for rtl::OString in std::ostream (and thus in
    1724             :     CPPUNIT_ASSERT or SAL_INFO macros, for example).
    1725             : 
    1726             :     @since LibreOffice 4.0
    1727             :  */
    1728             : template< typename charT, typename traits > std::basic_ostream<charT, traits> &
    1729           0 : operator <<(
    1730             :     std::basic_ostream<charT, traits> & stream, OString const & string)
    1731             : {
    1732           0 :     return stream << string.getStr();
    1733             :         // best effort; potentially loses data due to embedded null characters
    1734             : }
    1735             : 
    1736             : } /* Namespace */
    1737             : 
    1738             : #ifdef RTL_STRING_UNITTEST
    1739             : namespace rtl
    1740             : {
    1741             : typedef rtlunittest::OString OString;
    1742             : }
    1743             : #undef RTL_STRING_CONST_FUNCTION
    1744             : #endif
    1745             : 
    1746             : #ifdef RTL_USING
    1747             : using ::rtl::OString;
    1748             : using ::rtl::OStringHash;
    1749             : using ::rtl::OStringLiteral;
    1750             : #endif
    1751             : 
    1752             : #endif // INCLUDED_RTL_STRING_HXX
    1753             : 
    1754             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10