UDK 3.2.7 C/C++ API Reference

rtl/ustring.hxx

Go to the documentation of this file.
00001 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
00002 /*
00003  * This file is part of the LibreOffice project.
00004  *
00005  * This Source Code Form is subject to the terms of the Mozilla Public
00006  * License, v. 2.0. If a copy of the MPL was not distributed with this
00007  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
00008  *
00009  * This file incorporates work covered by the following license notice:
00010  *
00011  *   Licensed to the Apache Software Foundation (ASF) under one or more
00012  *   contributor license agreements. See the NOTICE file distributed
00013  *   with this work for additional information regarding copyright
00014  *   ownership. The ASF licenses this file to you under the Apache
00015  *   License, Version 2.0 (the "License"); you may not use this file
00016  *   except in compliance with the License. You may obtain a copy of
00017  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
00018  */
00019 
00020 #ifndef _RTL_USTRING_HXX_
00021 #define _RTL_USTRING_HXX_
00022 
00023 #include "sal/config.h"
00024 
00025 #include <cassert>
00026 #include <ostream>
00027 #include <string.h>
00028 
00029 #include "osl/diagnose.h"
00030 #include <rtl/ustring.h>
00031 #include <rtl/string.hxx>
00032 #include <rtl/stringutils.hxx>
00033 #include <rtl/textenc.h>
00034 #include "sal/log.hxx"
00035 
00036 #ifdef RTL_FAST_STRING
00037 #include <rtl/stringconcat.hxx>
00038 #endif
00039 
00040 #if defined EXCEPTIONS_OFF
00041 #include <stdlib.h>
00042 #else
00043 #include <new>
00044 #endif
00045 
00046 // The unittest uses slightly different code to help check that the proper
00047 // calls are made. The class is put into a different namespace to make
00048 // sure the compiler generates a different (if generating also non-inline)
00049 // copy of the function and does not merge them together. The class
00050 // is "brought" into the proper rtl namespace by a typedef below.
00051 #ifdef RTL_STRING_UNITTEST
00052 #define rtl rtlunittest
00053 #endif
00054 
00055 namespace rtl
00056 {
00057 
00058 #ifdef RTL_STRING_UNITTEST
00059 #undef rtl
00060 #endif
00061 
00062 /* ======================================================================= */
00063 
00087 class SAL_WARN_UNUSED OUString
00088 {
00089 public:
00091     rtl_uString * pData;
00093 
00094 private:
00095     class DO_NOT_ACQUIRE{};
00096 
00097     OUString( rtl_uString * value, SAL_UNUSED_PARAMETER DO_NOT_ACQUIRE * )
00098     {
00099         pData = value;
00100     }
00101 
00102 public:
00106     OUString() SAL_THROW(())
00107     {
00108         pData = 0;
00109         rtl_uString_new( &pData );
00110     }
00111 
00117     OUString( const OUString & str ) SAL_THROW(())
00118     {
00119         pData = str.pData;
00120         rtl_uString_acquire( pData );
00121     }
00122 
00128     OUString( rtl_uString * str )  SAL_THROW(())
00129     {
00130         pData = str;
00131         rtl_uString_acquire( pData );
00132     }
00133 
00142     inline OUString( rtl_uString * str, __sal_NoAcquire ) SAL_THROW(())
00143         { pData = str; }
00144 
00150     explicit OUString( sal_Unicode value ) SAL_THROW(())
00151         : pData (0)
00152     {
00153         rtl_uString_newFromStr_WithLength( &pData, &value, 1 );
00154     }
00155 
00161     OUString( const sal_Unicode * value ) SAL_THROW(())
00162     {
00163         pData = 0;
00164         rtl_uString_newFromStr( &pData, value );
00165     }
00166 
00175     OUString( const sal_Unicode * value, sal_Int32 length ) SAL_THROW(())
00176     {
00177         pData = 0;
00178         rtl_uString_newFromStr_WithLength( &pData, value, length );
00179     }
00180 
00196 #ifdef HAVE_SFINAE_ANONYMOUS_BROKEN
00197     // Old gcc can try to convert anonymous enums to OUString and give compile error.
00198     // So instead have a variant for const and non-const char[].
00199     template< int N >
00200     OUString( const char (&literal)[ N ] )
00201     {
00202         // Check that the string literal is in fact N - 1 long (no embedded \0's),
00203         // any decent compiler should optimize out calls to strlen with literals.
00204         assert( strlen( literal ) == N - 1 );
00205         pData = 0;
00206         rtl_uString_newFromLiteral( &pData, literal, N - 1, 0 );
00207 #ifdef RTL_STRING_UNITTEST
00208         rtl_string_unittest_const_literal = true;
00209 #endif
00210     }
00211 
00216     template< int N >
00217     OUString( char (&value)[ N ] )
00218 #ifndef RTL_STRING_UNITTEST
00219         ; // intentionally not implemented
00220 #else
00221     {
00222         (void) value; // unused
00223         pData = 0;
00224         rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
00225         rtl_string_unittest_invalid_conversion = true;
00226     }
00227 #endif
00228 #else // HAVE_SFINAE_ANONYMOUS_BROKEN
00229     template< typename T >
00230     OUString( T& literal, typename internal::ConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy() )
00231     {
00232         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00233         pData = 0;
00234         rtl_uString_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
00235 #ifdef RTL_STRING_UNITTEST
00236         rtl_string_unittest_const_literal = true;
00237 #endif
00238     }
00239 
00240 #endif // HAVE_SFINAE_ANONYMOUS_BROKEN
00241 
00242 
00243 #ifdef RTL_STRING_UNITTEST
00244 
00248     template< typename T >
00249     OUString( T&, typename internal::ExceptConstCharArrayDetector< T >::Type = internal::Dummy() )
00250     {
00251         pData = 0;
00252         rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
00253         rtl_string_unittest_invalid_conversion = true;
00254     }
00259     template< typename T >
00260     OUString( const T&, typename internal::ExceptCharArrayDetector< T >::Type = internal::Dummy() )
00261     {
00262         pData = 0;
00263         rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
00264         rtl_string_unittest_invalid_conversion = true;
00265     }
00266 #endif
00267 
00282     OUString( const sal_Char * value, sal_Int32 length,
00283               rtl_TextEncoding encoding,
00284               sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
00285     {
00286         pData = 0;
00287         rtl_string2UString( &pData, value, length, encoding, convertFlags );
00288         if (pData == 0) {
00289 #if defined EXCEPTIONS_OFF
00290             abort();
00291 #else
00292             throw std::bad_alloc();
00293 #endif
00294         }
00295     }
00296 
00313     inline explicit OUString(
00314         sal_uInt32 const * codePoints, sal_Int32 codePointCount):
00315         pData(NULL)
00316     {
00317         rtl_uString_newFromCodePoints(&pData, codePoints, codePointCount);
00318         if (pData == NULL) {
00319 #if defined EXCEPTIONS_OFF
00320             abort();
00321 #else
00322             throw std::bad_alloc();
00323 #endif
00324         }
00325     }
00326 
00327 #ifdef RTL_FAST_STRING
00328     template< typename T1, typename T2 >
00329     OUString( const OUStringConcat< T1, T2 >& c )
00330     {
00331         const sal_Int32 l = c.length();
00332         rtl_uString* buffer = NULL;
00333         rtl_uString_new_WithLength( &buffer, l ); // TODO this clears, not necessary
00334         if (l != 0)
00335         {
00336             sal_Unicode* end = c.addData( buffer->buffer );
00337             buffer->length = end - buffer->buffer;
00338             // TODO realloc in case buffer->length is noticeably smaller than l?
00339         }
00340         pData = buffer;
00341     }
00342 #endif
00343 
00347     ~OUString() SAL_THROW(())
00348     {
00349         rtl_uString_release( pData );
00350     }
00351 
00363     static inline OUString const & unacquired( rtl_uString * const * ppHandle )
00364         { return * reinterpret_cast< OUString const * >( ppHandle ); }
00365 
00371     OUString & operator=( const OUString & str ) SAL_THROW(())
00372     {
00373         rtl_uString_assign( &pData, str.pData );
00374         return *this;
00375     }
00376 
00389     template< typename T >
00390     typename internal::ConstCharArrayDetector< T, OUString& >::Type operator=( T& literal )
00391     {
00392         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00393         rtl_uString_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
00394         return *this;
00395     }
00396 
00402     OUString & operator+=( const OUString & str ) SAL_THROW(())
00403     {
00404         rtl_uString_newConcat( &pData, pData, str.pData );
00405         return *this;
00406     }
00407 
00416     sal_Int32 getLength() const SAL_THROW(()) { return pData->length; }
00417 
00426     bool isEmpty() const SAL_THROW(())
00427     {
00428         return pData->length == 0;
00429     }
00430 
00438     const sal_Unicode * getStr() const SAL_THROW(()) { return pData->buffer; }
00439 
00449     sal_Unicode operator [](sal_Int32 index) const { return getStr()[index]; }
00450 
00463     sal_Int32 compareTo( const OUString & str ) const SAL_THROW(())
00464     {
00465         return rtl_ustr_compare_WithLength( pData->buffer, pData->length,
00466                                             str.pData->buffer, str.pData->length );
00467     }
00468 
00484     sal_Int32 compareTo( const OUString & str, sal_Int32 maxLength ) const SAL_THROW(())
00485     {
00486         return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length,
00487                                                      str.pData->buffer, str.pData->length, maxLength );
00488     }
00489 
00502     sal_Int32 reverseCompareTo( const OUString & str ) const SAL_THROW(())
00503     {
00504         return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
00505                                                    str.pData->buffer, str.pData->length );
00506     }
00507 
00519     sal_Bool equals( const OUString & str ) const SAL_THROW(())
00520     {
00521         if ( pData->length != str.pData->length )
00522             return sal_False;
00523         if ( pData == str.pData )
00524             return sal_True;
00525         return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
00526                                                    str.pData->buffer, str.pData->length ) == 0;
00527     }
00528 
00543     sal_Bool equalsIgnoreAsciiCase( const OUString & str ) const SAL_THROW(())
00544     {
00545         if ( pData->length != str.pData->length )
00546             return sal_False;
00547         if ( pData == str.pData )
00548             return sal_True;
00549         return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
00550                                                            str.pData->buffer, str.pData->length ) == 0;
00551     }
00552 
00568     sal_Int32 compareToIgnoreAsciiCase( const OUString & str ) const SAL_THROW(())
00569     {
00570         return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
00571                                                            str.pData->buffer, str.pData->length );
00572     }
00573 
00574 
00580     template< typename T >
00581     typename internal::ConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase( T& literal ) const SAL_THROW(())
00582     {
00583         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00584         if ( pData->length != internal::ConstCharArrayDetector< T, void >::size - 1 )
00585             return sal_False;
00586 
00587         return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, literal ) == 0;
00588     }
00589 
00605     sal_Bool match( const OUString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
00606     {
00607         return rtl_ustr_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
00608                                                      str.pData->buffer, str.pData->length, str.pData->length ) == 0;
00609     }
00610 
00616     template< typename T >
00617     typename internal::ConstCharArrayDetector< T, bool >::Type match( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
00618     {
00619         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00620         return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
00621             literal, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
00622     }
00623 
00642     sal_Bool matchIgnoreAsciiCase( const OUString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
00643     {
00644         return rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
00645                                                                     str.pData->buffer, str.pData->length,
00646                                                                     str.pData->length ) == 0;
00647     }
00648 
00654     template< typename T >
00655     typename internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
00656     {
00657         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00658         return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
00659             literal, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
00660     }
00661 
00678     sal_Int32 compareToAscii( const sal_Char* asciiStr ) const SAL_THROW(())
00679     {
00680         return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length, asciiStr );
00681     }
00682 
00700     sal_Int32 compareToAscii( const sal_Char * asciiStr, sal_Int32 maxLength ) const SAL_THROW(())
00701     {
00702         return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer, pData->length,
00703                                                            asciiStr, maxLength );
00704     }
00705 
00725     sal_Int32 reverseCompareToAsciiL( const sal_Char * asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(())
00726     {
00727         return rtl_ustr_asciil_reverseCompare_WithLength( pData->buffer, pData->length,
00728                                                           asciiStr, asciiStrLength );
00729     }
00730 
00746     sal_Bool equalsAscii( const sal_Char* asciiStr ) const SAL_THROW(())
00747     {
00748         return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length,
00749                                                   asciiStr ) == 0;
00750     }
00751 
00769     sal_Bool equalsAsciiL( const sal_Char* asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(())
00770     {
00771         if ( pData->length != asciiStrLength )
00772             return sal_False;
00773 
00774         return rtl_ustr_asciil_reverseEquals_WithLength(
00775                     pData->buffer, asciiStr, asciiStrLength );
00776     }
00777 
00796     sal_Bool equalsIgnoreAsciiCaseAscii( const sal_Char * asciiStr ) const SAL_THROW(())
00797     {
00798         return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
00799     }
00800 
00819     sal_Int32 compareToIgnoreAsciiCaseAscii( const sal_Char * asciiStr ) const SAL_THROW(())
00820     {
00821         return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr );
00822     }
00823 
00844     sal_Bool equalsIgnoreAsciiCaseAsciiL( const sal_Char * asciiStr, sal_Int32 asciiStrLength ) const SAL_THROW(())
00845     {
00846         if ( pData->length != asciiStrLength )
00847             return sal_False;
00848 
00849         return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
00850     }
00851 
00873     sal_Bool matchAsciiL( const sal_Char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
00874     {
00875         return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
00876                                                            asciiStr, asciiStrLength ) == 0;
00877     }
00878 
00879     // This overload is left undefined, to detect calls of matchAsciiL that
00880     // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
00881     // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
00882     // platforms):
00883 #if SAL_TYPES_SIZEOFLONG == 8
00884     void matchAsciiL(char const *, sal_Int32, rtl_TextEncoding) const;
00885 #endif
00886 
00911     sal_Bool matchIgnoreAsciiCaseAsciiL( const sal_Char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
00912     {
00913         return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
00914                                                                           asciiStr, asciiStrLength ) == 0;
00915     }
00916 
00917     // This overload is left undefined, to detect calls of
00918     // matchIgnoreAsciiCaseAsciiL that erroneously use
00919     // RTL_CONSTASCII_USTRINGPARAM instead of RTL_CONSTASCII_STRINGPARAM (but
00920     // would lead to ambiguities on 32 bit platforms):
00921 #if SAL_TYPES_SIZEOFLONG == 8
00922     void matchIgnoreAsciiCaseAsciiL(char const *, sal_Int32, rtl_TextEncoding)
00923         const;
00924 #endif
00925 
00936     bool startsWith(OUString const & str) const {
00937         return match(str, 0);
00938     }
00939 
00945     template< typename T >
00946     typename internal::ConstCharArrayDetector< T, bool >::Type startsWith( T& literal ) const
00947     {
00948         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00949         return internal::ConstCharArrayDetector< T, void >::size - 1 <= pData->length
00950             && rtl_ustr_asciil_reverseEquals_WithLength( pData->buffer, literal,
00951                 internal::ConstCharArrayDetector< T, void >::size - 1);
00952     }
00953 
00967     sal_Bool startsWithIgnoreAsciiCase( const OUString & str ) const SAL_THROW(())
00968     {
00969         return matchIgnoreAsciiCase(str, 0);
00970     }
00971 
00977     template< typename T >
00978     typename internal::ConstCharArrayDetector< T, bool >::Type startsWithIgnoreAsciiCase( T& literal ) const SAL_THROW(())
00979     {
00980         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
00981         return (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
00982                     pData->buffer,
00983                     internal::ConstCharArrayDetector< T, void >::size - 1, literal,
00984                     internal::ConstCharArrayDetector< T, void >::size - 1)
00985                 == 0);
00986     }
00987 
00998     bool endsWith(OUString const & str) const {
00999         return str.getLength() <= getLength()
01000             && match(str, getLength() - str.getLength());
01001     }
01002 
01008     template< typename T >
01009     typename internal::ConstCharArrayDetector< T, bool >::Type endsWith( T& literal ) const
01010     {
01011         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01012         return internal::ConstCharArrayDetector< T, void >::size - 1 <= pData->length
01013             && rtl_ustr_asciil_reverseEquals_WithLength(
01014                 pData->buffer + pData->length - ( internal::ConstCharArrayDetector< T, void >::size - 1 ), literal,
01015                 internal::ConstCharArrayDetector< T, void >::size - 1);
01016     }
01017 
01029     inline bool endsWithAsciiL(char const * asciiStr, sal_Int32 asciiStrLength)
01030         const
01031     {
01032         return asciiStrLength <= pData->length
01033             && rtl_ustr_asciil_reverseEquals_WithLength(
01034                 pData->buffer + pData->length - asciiStrLength, asciiStr,
01035                 asciiStrLength);
01036     }
01037 
01051     sal_Bool endsWithIgnoreAsciiCase( const OUString & str ) const SAL_THROW(())
01052     {
01053         return str.getLength() <= getLength()
01054             && matchIgnoreAsciiCase(str, getLength() - str.getLength());
01055     }
01056 
01062     template< typename T >
01063     typename internal::ConstCharArrayDetector< T, bool >::Type endsWithIgnoreAsciiCase( T& literal ) const SAL_THROW(())
01064     {
01065         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01066         return internal::ConstCharArrayDetector< T, void >::size - 1 <= pData->length
01067             && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
01068                     pData->buffer + pData->length - ( internal::ConstCharArrayDetector< T, void >::size - 1 ),
01069                     internal::ConstCharArrayDetector< T, void >::size - 1, literal,
01070                     internal::ConstCharArrayDetector< T, void >::size - 1)
01071                 == 0);
01072     }
01073 
01084     inline bool endsWithIgnoreAsciiCaseAsciiL(
01085         char const * asciiStr, sal_Int32 asciiStrLength) const
01086     {
01087         return asciiStrLength <= pData->length
01088             && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
01089                     pData->buffer + pData->length - asciiStrLength,
01090                     asciiStrLength, asciiStr, asciiStrLength)
01091                 == 0);
01092     }
01093 
01094     friend sal_Bool     operator == ( const OUString& rStr1,    const OUString& rStr2 ) SAL_THROW(())
01095                         { return rStr1.equals(rStr2); }
01096     friend sal_Bool     operator == ( const OUString& rStr1,    const sal_Unicode * pStr2 ) SAL_THROW(())
01097                         { return rStr1.compareTo( pStr2 ) == 0; }
01098     friend sal_Bool     operator == ( const sal_Unicode * pStr1,    const OUString& rStr2 ) SAL_THROW(())
01099                         { return OUString( pStr1 ).compareTo( rStr2 ) == 0; }
01100 
01101     friend sal_Bool     operator != ( const OUString& rStr1,        const OUString& rStr2 ) SAL_THROW(())
01102                         { return !(operator == ( rStr1, rStr2 )); }
01103     friend sal_Bool     operator != ( const OUString& rStr1,    const sal_Unicode * pStr2 ) SAL_THROW(())
01104                         { return !(operator == ( rStr1, pStr2 )); }
01105     friend sal_Bool     operator != ( const sal_Unicode * pStr1,    const OUString& rStr2 ) SAL_THROW(())
01106                         { return !(operator == ( pStr1, rStr2 )); }
01107 
01108     friend sal_Bool     operator <  ( const OUString& rStr1,    const OUString& rStr2 ) SAL_THROW(())
01109                         { return rStr1.compareTo( rStr2 ) < 0; }
01110     friend sal_Bool     operator >  ( const OUString& rStr1,    const OUString& rStr2 ) SAL_THROW(())
01111                         { return rStr1.compareTo( rStr2 ) > 0; }
01112     friend sal_Bool     operator <= ( const OUString& rStr1,    const OUString& rStr2 ) SAL_THROW(())
01113                         { return rStr1.compareTo( rStr2 ) <= 0; }
01114     friend sal_Bool     operator >= ( const OUString& rStr1,    const OUString& rStr2 ) SAL_THROW(())
01115                         { return rStr1.compareTo( rStr2 ) >= 0; }
01116 
01124     template< typename T >
01125     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator==( const OUString& string, T& literal )
01126     {
01127         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01128         return string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
01129     }
01137     template< typename T >
01138     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OUString& string )
01139     {
01140         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01141         return string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
01142     }
01150     template< typename T >
01151     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator!=( const OUString& string, T& literal )
01152     {
01153         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01154         return !string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
01155     }
01163     template< typename T >
01164     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator!=( T& literal, const OUString& string )
01165     {
01166         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01167         return !string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
01168     }
01169 
01177     sal_Int32 hashCode() const SAL_THROW(())
01178     {
01179         return rtl_ustr_hashCode_WithLength( pData->buffer, pData->length );
01180     }
01181 
01195     sal_Int32 indexOf( sal_Unicode ch, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
01196     {
01197         sal_Int32 ret = rtl_ustr_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
01198         return (ret < 0 ? ret : ret+fromIndex);
01199     }
01200 
01210     sal_Int32 lastIndexOf( sal_Unicode ch ) const SAL_THROW(())
01211     {
01212         return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
01213     }
01214 
01227     sal_Int32 lastIndexOf( sal_Unicode ch, sal_Int32 fromIndex ) const SAL_THROW(())
01228     {
01229         return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
01230     }
01231 
01247     sal_Int32 indexOf( const OUString & str, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
01248     {
01249         sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
01250                                                         str.pData->buffer, str.pData->length );
01251         return (ret < 0 ? ret : ret+fromIndex);
01252     }
01253 
01259     template< typename T >
01260     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
01261     {
01262         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01263         sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
01264             pData->buffer + fromIndex, pData->length - fromIndex, literal,
01265             internal::ConstCharArrayDetector< T, void >::size - 1);
01266         return ret < 0 ? ret : ret + fromIndex;
01267     }
01268 
01292     sal_Int32 indexOfAsciiL(
01293         char const * str, sal_Int32 len, sal_Int32 fromIndex = 0) const
01294         SAL_THROW(())
01295     {
01296         sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
01297             pData->buffer + fromIndex, pData->length - fromIndex, str, len);
01298         return ret < 0 ? ret : ret + fromIndex;
01299     }
01300 
01301     // This overload is left undefined, to detect calls of indexOfAsciiL that
01302     // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
01303     // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
01304     // platforms):
01305 #if SAL_TYPES_SIZEOFLONG == 8
01306     void indexOfAsciiL(char const *, sal_Int32 len, rtl_TextEncoding) const;
01307 #endif
01308 
01324     sal_Int32 lastIndexOf( const OUString & str ) const SAL_THROW(())
01325     {
01326         return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length,
01327                                                    str.pData->buffer, str.pData->length );
01328     }
01329 
01347     sal_Int32 lastIndexOf( const OUString & str, sal_Int32 fromIndex ) const SAL_THROW(())
01348     {
01349         return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
01350                                                    str.pData->buffer, str.pData->length );
01351     }
01352 
01358     template< typename T >
01359     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf( T& literal ) const SAL_THROW(())
01360     {
01361         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
01362         return rtl_ustr_lastIndexOfAscii_WithLength(
01363             pData->buffer, pData->length, literal, internal::ConstCharArrayDetector< T, void >::size - 1);
01364     }
01365 
01385     sal_Int32 lastIndexOfAsciiL(char const * str, sal_Int32 len) const
01386         SAL_THROW(())
01387     {
01388         return rtl_ustr_lastIndexOfAscii_WithLength(
01389             pData->buffer, pData->length, str, len);
01390     }
01391 
01402     OUString copy( sal_Int32 beginIndex ) const SAL_THROW(())
01403     {
01404         rtl_uString *pNew = 0;
01405         rtl_uString_newFromSubString( &pNew, pData, beginIndex, getLength() - beginIndex );
01406         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01407     }
01408 
01421     OUString copy( sal_Int32 beginIndex, sal_Int32 count ) const SAL_THROW(())
01422     {
01423         rtl_uString *pNew = 0;
01424         rtl_uString_newFromSubString( &pNew, pData, beginIndex, count );
01425         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01426     }
01427 
01436     SAL_WARN_UNUSED_RESULT OUString concat( const OUString & str ) const SAL_THROW(())
01437     {
01438         rtl_uString* pNew = 0;
01439         rtl_uString_newConcat( &pNew, pData, str.pData );
01440         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01441     }
01442 
01443 #ifndef RTL_FAST_STRING
01444     friend OUString operator+( const OUString& rStr1, const OUString& rStr2  ) SAL_THROW(())
01445     {
01446         return rStr1.concat( rStr2 );
01447     }
01448 #endif
01449 
01463     SAL_WARN_UNUSED_RESULT OUString replaceAt( sal_Int32 index, sal_Int32 count, const OUString& newStr ) const SAL_THROW(())
01464     {
01465         rtl_uString* pNew = 0;
01466         rtl_uString_newReplaceStrAt( &pNew, pData, index, count, newStr.pData );
01467         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01468     }
01469 
01483     SAL_WARN_UNUSED_RESULT OUString replace( sal_Unicode oldChar, sal_Unicode newChar ) const SAL_THROW(())
01484     {
01485         rtl_uString* pNew = 0;
01486         rtl_uString_newReplace( &pNew, pData, oldChar, newChar );
01487         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01488     }
01489 
01508     SAL_WARN_UNUSED_RESULT OUString replaceFirst(
01509         OUString const & from, OUString const & to, sal_Int32 * index = 0) const
01510     {
01511         rtl_uString * s = 0;
01512         sal_Int32 i = 0;
01513         rtl_uString_newReplaceFirst(
01514             &s, pData, from.pData, to.pData, index == 0 ? &i : index);
01515         return OUString(s, SAL_NO_ACQUIRE);
01516     }
01517 
01536     template< typename T >
01537     SAL_WARN_UNUSED_RESULT typename internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst( T& from, OUString const & to,
01538                                                                                                         sal_Int32 * index = 0) const
01539     {
01540         rtl_uString * s = 0;
01541         sal_Int32 i = 0;
01542         assert( strlen( from ) == internal::ConstCharArrayDetector< T >::size - 1 );
01543         rtl_uString_newReplaceFirstAsciiL(
01544             &s, pData, from, internal::ConstCharArrayDetector< T, void >::size - 1, to.pData, index == 0 ? &i : index);
01545         return OUString(s, SAL_NO_ACQUIRE);
01546     }
01547 
01566     template< typename T1, typename T2 >
01567         SAL_WARN_UNUSED_RESULT typename internal::ConstCharArrayDetector< T1, typename internal::ConstCharArrayDetector< T2, OUString >::Type >::Type
01568         replaceFirst( T1& from, T2& to, sal_Int32 * index = 0) const
01569     {
01570         rtl_uString * s = 0;
01571         sal_Int32 i = 0;
01572         assert( strlen( from ) == internal::ConstCharArrayDetector< T1 >::size - 1 );
01573         assert( strlen( to ) == internal::ConstCharArrayDetector< T2 >::size - 1 );
01574         rtl_uString_newReplaceFirstAsciiLAsciiL(
01575             &s, pData, from, internal::ConstCharArrayDetector< T1, void >::size - 1, to,
01576             internal::ConstCharArrayDetector< T2, void >::size - 1, index == 0 ? &i : index);
01577         return OUString(s, SAL_NO_ACQUIRE);
01578     }
01579 
01595     OUString replaceAll(OUString const & from, OUString const & to, sal_Int32 fromIndex = 0) const {
01596         rtl_uString * s = 0;
01597         rtl_uString_newReplaceAllFromIndex(&s, pData, from.pData, to.pData, fromIndex);
01598         return OUString(s, SAL_NO_ACQUIRE);
01599     }
01600 
01614     template< typename T >
01615     typename internal::ConstCharArrayDetector< T, OUString >::Type replaceAll( T& from, OUString const & to) const
01616     {
01617         rtl_uString * s = 0;
01618         assert( strlen( from ) == internal::ConstCharArrayDetector< T >::size - 1 );
01619         rtl_uString_newReplaceAllAsciiL(&s, pData, from, internal::ConstCharArrayDetector< T, void >::size - 1, to.pData);
01620         return OUString(s, SAL_NO_ACQUIRE);
01621     }
01622 
01636     template< typename T1, typename T2 >
01637     typename internal::ConstCharArrayDetector< T1, typename internal::ConstCharArrayDetector< T2, OUString >::Type >::Type
01638         replaceAll( T1& from, T2& to ) const
01639     {
01640         rtl_uString * s = 0;
01641         assert( strlen( from ) == internal::ConstCharArrayDetector< T1 >::size - 1 );
01642         assert( strlen( to ) == internal::ConstCharArrayDetector< T2 >::size - 1 );
01643         rtl_uString_newReplaceAllAsciiLAsciiL(
01644             &s, pData, from, internal::ConstCharArrayDetector< T1, void >::size - 1,
01645             to, internal::ConstCharArrayDetector< T2, void >::size - 1);
01646         return OUString(s, SAL_NO_ACQUIRE);
01647     }
01648 
01659     SAL_WARN_UNUSED_RESULT OUString toAsciiLowerCase() const SAL_THROW(())
01660     {
01661         rtl_uString* pNew = 0;
01662         rtl_uString_newToAsciiLowerCase( &pNew, pData );
01663         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01664     }
01665 
01676     SAL_WARN_UNUSED_RESULT OUString toAsciiUpperCase() const SAL_THROW(())
01677     {
01678         rtl_uString* pNew = 0;
01679         rtl_uString_newToAsciiUpperCase( &pNew, pData );
01680         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01681     }
01682 
01694     SAL_WARN_UNUSED_RESULT OUString trim() const SAL_THROW(())
01695     {
01696         rtl_uString* pNew = 0;
01697         rtl_uString_newTrim( &pNew, pData );
01698         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
01699     }
01700 
01725     OUString getToken( sal_Int32 token, sal_Unicode cTok, sal_Int32& index ) const SAL_THROW(())
01726     {
01727         rtl_uString * pNew = 0;
01728         index = rtl_uString_getToken( &pNew, pData, token, cTok, index );
01729         return OUString( pNew, (DO_NOT_ACQUIRE *)0 );
01730     }
01731 
01745     OUString getToken(sal_Int32 count, sal_Unicode separator) const {
01746         sal_Int32 n = 0;
01747         return getToken(count, separator, n);
01748     }
01749 
01758     sal_Bool toBoolean() const SAL_THROW(())
01759     {
01760         return rtl_ustr_toBoolean( pData->buffer );
01761     }
01762 
01769     sal_Unicode toChar() const SAL_THROW(())
01770     {
01771         return pData->buffer[0];
01772     }
01773 
01783     sal_Int32 toInt32( sal_Int16 radix = 10 ) const SAL_THROW(())
01784     {
01785         return rtl_ustr_toInt32( pData->buffer, radix );
01786     }
01787 
01797     sal_Int64 toInt64( sal_Int16 radix = 10 ) const SAL_THROW(())
01798     {
01799         return rtl_ustr_toInt64( pData->buffer, radix );
01800     }
01801 
01810     float toFloat() const SAL_THROW(())
01811     {
01812         return rtl_ustr_toFloat( pData->buffer );
01813     }
01814 
01823     double toDouble() const SAL_THROW(())
01824     {
01825         return rtl_ustr_toDouble( pData->buffer );
01826     }
01827 
01828 
01844     OUString intern() const
01845     {
01846         rtl_uString * pNew = 0;
01847         rtl_uString_intern( &pNew, pData );
01848         if (pNew == 0) {
01849 #if defined EXCEPTIONS_OFF
01850             abort();
01851 #else
01852             throw std::bad_alloc();
01853 #endif
01854         }
01855         return OUString( pNew, (DO_NOT_ACQUIRE *)0 );
01856     }
01857 
01883     static OUString intern( const sal_Char * value, sal_Int32 length,
01884                             rtl_TextEncoding encoding,
01885                             sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS,
01886                             sal_uInt32 *pInfo = NULL )
01887     {
01888         rtl_uString * pNew = 0;
01889         rtl_uString_internConvert( &pNew, value, length, encoding,
01890                                    convertFlags, pInfo );
01891         if (pNew == 0) {
01892 #if defined EXCEPTIONS_OFF
01893             abort();
01894 #else
01895             throw std::bad_alloc();
01896 #endif
01897         }
01898         return OUString( pNew, (DO_NOT_ACQUIRE *)0 );
01899     }
01900 
01925     inline bool convertToString(OString * pTarget, rtl_TextEncoding nEncoding,
01926                                 sal_uInt32 nFlags) const
01927     {
01928         return rtl_convertUStringToString(&pTarget->pData, pData->buffer,
01929                                             pData->length, nEncoding, nFlags);
01930     }
01931 
01983     inline sal_uInt32 iterateCodePoints(
01984         sal_Int32 * indexUtf16, sal_Int32 incrementCodePoints = 1) const
01985     {
01986         return rtl_uString_iterateCodePoints(
01987             pData, indexUtf16, incrementCodePoints);
01988     }
01989 
02000     static OUString valueOf( sal_Bool b ) SAL_THROW(())
02001     {
02002         sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFBOOLEAN];
02003         rtl_uString* pNewData = 0;
02004         rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfBoolean( aBuf, b ) );
02005         return OUString( pNewData, (DO_NOT_ACQUIRE*)0 );
02006     }
02007 
02014     static OUString valueOf( sal_Unicode c ) SAL_THROW(())
02015     {
02016         return OUString( &c, 1 );
02017     }
02018 
02028     static OUString valueOf( sal_Int32 i, sal_Int16 radix = 10 ) SAL_THROW(())
02029     {
02030         sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT32];
02031         rtl_uString* pNewData = 0;
02032         rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfInt32( aBuf, i, radix ) );
02033         return OUString( pNewData, (DO_NOT_ACQUIRE*)0 );
02034     }
02035 
02045     static OUString valueOf( sal_Int64 ll, sal_Int16 radix = 10 ) SAL_THROW(())
02046     {
02047         sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT64];
02048         rtl_uString* pNewData = 0;
02049         rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfInt64( aBuf, ll, radix ) );
02050         return OUString( pNewData, (DO_NOT_ACQUIRE*)0 );
02051     }
02052 
02061     static OUString valueOf( float f ) SAL_THROW(())
02062     {
02063         sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFFLOAT];
02064         rtl_uString* pNewData = 0;
02065         rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfFloat( aBuf, f ) );
02066         return OUString( pNewData, (DO_NOT_ACQUIRE*)0 );
02067     }
02068 
02077     static OUString valueOf( double d ) SAL_THROW(())
02078     {
02079         sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFDOUBLE];
02080         rtl_uString* pNewData = 0;
02081         rtl_uString_newFromStr_WithLength( &pNewData, aBuf, rtl_ustr_valueOfDouble( aBuf, d ) );
02082         return OUString( pNewData, (DO_NOT_ACQUIRE*)0 );
02083     }
02084 
02100     static OUString createFromAscii( const sal_Char * value ) SAL_THROW(())
02101     {
02102         rtl_uString* pNew = 0;
02103         rtl_uString_newFromAscii( &pNew, value );
02104         return OUString( pNew, (DO_NOT_ACQUIRE*)0 );
02105     }
02106 
02107     template< typename T1, typename T2 >
02108     friend struct OUStringConcat;
02109 };
02110 
02111 /* ======================================================================= */
02112 
02113 #ifdef RTL_FAST_STRING
02114 
02122 struct SAL_WARN_UNUSED OUStringLiteral
02123 {
02124     template< int N >
02125     OUStringLiteral( const char (&str)[ N ] ) : size( N - 1 ), data( str ) { assert( strlen( str ) == N - 1 ); }
02126     int size;
02127     const char* data;
02128 };
02129 
02130 template<>
02131 struct ToStringHelper< OUString >
02132     {
02133     static int length( const OUString& s ) { return s.getLength(); }
02134     static sal_Unicode* addData( sal_Unicode* buffer, const OUString& s ) { return addDataHelper( buffer, s.getStr(), s.getLength()); }
02135     static const bool allowOStringConcat = false;
02136     static const bool allowOUStringConcat = true;
02137     };
02138 
02139 template<>
02140 struct ToStringHelper< OUStringLiteral >
02141     {
02142     static int length( const OUStringLiteral& str ) { return str.size; }
02143     static sal_Unicode* addData( sal_Unicode* buffer, const OUStringLiteral& str ) { return addDataLiteral( buffer, str.data, str.size ); }
02144     static const bool allowOStringConcat = false;
02145     static const bool allowOUStringConcat = true;
02146     };
02147 
02148 template< typename charT, typename traits, typename T1, typename T2 >
02149 inline std::basic_ostream<charT, traits> & operator <<(
02150     std::basic_ostream<charT, traits> & stream, const OUStringConcat< T1, T2 >& concat)
02151 {
02152     return stream << OUString( concat );
02153 }
02154 #else
02155 // non-RTL_FAST_CODE needs this to compile
02156 typedef OUString OUStringLiteral;
02157 #endif
02158 
02159 } /* Namespace */
02160 
02161 #ifdef RTL_STRING_UNITTEST
02162 namespace rtl
02163 {
02164 typedef rtlunittest::OUString OUString;
02165 }
02166 #endif
02167 
02168 namespace rtl
02169 {
02170 
02176 struct OUStringHash
02177 {
02187     size_t operator()(const OUString& rString) const
02188         { return (size_t)rString.hashCode(); }
02189 };
02190 
02191 /* ======================================================================= */
02192 
02210 inline OUString OStringToOUString( const OString & rStr,
02211                                    rtl_TextEncoding encoding,
02212                                    sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
02213 {
02214     return OUString( rStr.getStr(), rStr.getLength(), encoding, convertFlags );
02215 }
02216 
02234 inline OString OUStringToOString( const OUString & rUnicode,
02235                                   rtl_TextEncoding encoding,
02236                                   sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
02237 {
02238     return OString( rUnicode.getStr(), rUnicode.getLength(), encoding, convertFlags );
02239 }
02240 
02241 /* ======================================================================= */
02242 
02243 } /* Namespace */
02244 
02245 #ifdef RTL_STRING_UNITTEST
02246 #define rtl rtlunittest
02247 #endif
02248 namespace rtl
02249 {
02250 #ifdef RTL_STRING_UNITTEST
02251 #undef rtl
02252 #endif
02253 
02262 template< typename charT, typename traits >
02263 inline std::basic_ostream<charT, traits> & operator <<(
02264     std::basic_ostream<charT, traits> & stream, OUString const & string)
02265 {
02266     return stream <<
02267         rtl::OUStringToOString(string, RTL_TEXTENCODING_UTF8).getStr();
02268         // best effort; potentially loses data due to conversion failures
02269         // (stray surrogate halves) and embedded null characters
02270 }
02271 
02272 } // namespace
02273 
02274 // RTL_USING is defined by gbuild for all modules except those with stable public API
02275 // (as listed in ure/source/README). It allows to use classes like OUString without
02276 // having to explicitly refer to the rtl namespace, which is kind of superfluous
02277 // given that OUString itself is namespaced by its OU prefix.
02278 #ifdef RTL_USING
02279 using ::rtl::OUString;
02280 using ::rtl::OUStringHash;
02281 using ::rtl::OStringToOUString;
02282 using ::rtl::OUStringToOString;
02283 using ::rtl::OUStringLiteral;
02284 #endif
02285 
02286 #endif /* _RTL_USTRING_HXX */
02287 
02288 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines