LCOV - code coverage report
Current view: top level - libreoffice/solver/unxlngi6.pro/inc/rtl - strbuf.hxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 110 120 91.7 %
Date: 2012-12-27 Functions: 76 153 49.7 %
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 _RTL_STRBUF_HXX_
      21             : #define _RTL_STRBUF_HXX_
      22             : 
      23             : #include "sal/config.h"
      24             : 
      25             : #include <cassert>
      26             : #include <string.h>
      27             : 
      28             : #include <rtl/strbuf.h>
      29             : #include <rtl/string.hxx>
      30             : #include <rtl/stringutils.hxx>
      31             : 
      32             : #ifdef RTL_FAST_STRING
      33             : #include <rtl/stringconcat.hxx>
      34             : #endif
      35             : 
      36             : #ifdef __cplusplus
      37             : 
      38             : // The unittest uses slightly different code to help check that the proper
      39             : // calls are made. The class is put into a different namespace to make
      40             : // sure the compiler generates a different (if generating also non-inline)
      41             : // copy of the function and does not merge them together. The class
      42             : // is "brought" into the proper rtl namespace by a typedef below.
      43             : #ifdef RTL_STRING_UNITTEST
      44             : #define rtl rtlunittest
      45             : #endif
      46             : 
      47             : namespace rtl
      48             : {
      49             : 
      50             : #ifdef RTL_STRING_UNITTEST
      51             : #undef rtl
      52             : // helper macro to make functions appear more readable
      53             : #define RTL_STRING_CONST_FUNCTION rtl_string_unittest_const_literal_function = true;
      54             : #else
      55             : #define RTL_STRING_CONST_FUNCTION
      56             : #endif
      57             : 
      58             : /** A string buffer implements a mutable sequence of characters.
      59             :     <p>
      60             :     String buffers are safe for use by multiple threads. The methods
      61             :     are synchronized where necessary so that all the operations on any
      62             :     particular instance behave as if they occur in some serial order.
      63             :     <p>
      64             :     String buffers are used by the compiler to implement the binary
      65             :     string concatenation operator <code>+</code>. For example, the code:
      66             :     <p><blockquote><pre>
      67             :         x = "a" + 4 + "c"
      68             :     </pre></blockquote><p>
      69             :     is compiled to the equivalent of:
      70             :     <p><blockquote><pre>
      71             :         x = new OStringBuffer().append("a").append(4).append("c")
      72             :                               .makeStringAndClear()
      73             :     </pre></blockquote><p>
      74             :     The principal operations on a <code>OStringBuffer</code> are the
      75             :     <code>append</code> and <code>insert</code> methods, which are
      76             :     overloaded so as to accept data of any type. Each effectively
      77             :     converts a given datum to a string and then appends or inserts the
      78             :     characters of that string to the string buffer. The
      79             :     <code>append</code> method always adds these characters at the end
      80             :     of the buffer; the <code>insert</code> method adds the characters at
      81             :     a specified point.
      82             :     <p>
      83             :     For example, if <code>z</code> refers to a string buffer object
      84             :     whose current contents are "<code>start</code>", then
      85             :     the method call <code>z.append("le")</code> would cause the string
      86             :     buffer to contain "<code>startle</code>", whereas
      87             :     <code>z.insert(4, "le")</code> would alter the string buffer to
      88             :     contain "<code>starlet</code>".
      89             :     <p>
      90             :     Every string buffer has a capacity. As long as the length of the
      91             :     character sequence contained in the string buffer does not exceed
      92             :     the capacity, it is not necessary to allocate a new internal
      93             :     buffer array. If the internal buffer overflows, it is
      94             :     automatically made larger.
      95             :  */
      96             : class SAL_WARN_UNUSED OStringBuffer
      97             : {
      98             : public:
      99             :     /**
     100             :         Constructs a string buffer with no characters in it and an
     101             :         initial capacity of 16 characters.
     102             :      */
     103     1257414 :     OStringBuffer()
     104             :         : pData(NULL)
     105     1257414 :         , nCapacity( 16 )
     106             :     {
     107     1257414 :         rtl_string_new_WithLength( &pData, nCapacity );
     108     1257414 :     }
     109             : 
     110             :     /**
     111             :         Allocates a new string buffer that contains the same sequence of
     112             :         characters as the string buffer argument.
     113             : 
     114             :         @param   value   a <code>OStringBuffer</code>.
     115             :      */
     116        8528 :     OStringBuffer( const OStringBuffer & value )
     117             :         : pData(NULL)
     118        8528 :         , nCapacity( value.nCapacity )
     119             :     {
     120        8528 :         rtl_stringbuffer_newFromStringBuffer( &pData, value.nCapacity, value.pData );
     121        8528 :     }
     122             : 
     123             :     /**
     124             :         Constructs a string buffer with no characters in it and an
     125             :         initial capacity specified by the <code>length</code> argument.
     126             : 
     127             :         @param      length   the initial capacity.
     128             :      */
     129     2163350 :     explicit OStringBuffer(int length)
     130             :         : pData(NULL)
     131     2163350 :         , nCapacity( length )
     132             :     {
     133     2163350 :         rtl_string_new_WithLength( &pData, length );
     134     2163350 :     }
     135             : 
     136             :     /**
     137             :         Constructs a string buffer so that it represents the same
     138             :         sequence of characters as the string argument.
     139             : 
     140             :         The initial
     141             :         capacity of the string buffer is <code>16</code> plus the length
     142             :         of the string argument.
     143             : 
     144             :         @param   value   the initial string value.
     145             :      */
     146       38082 :     OStringBuffer(const OString& value)
     147             :         : pData(NULL)
     148       38082 :         , nCapacity( value.getLength() + 16 )
     149             :     {
     150       38082 :         rtl_stringbuffer_newFromStr_WithLength( &pData, value.getStr(), value.getLength() );
     151       38082 :     }
     152             : 
     153             :     /**
     154             :         @overload
     155             :         @since LibreOffice 3.6
     156             :      */
     157             : #ifdef HAVE_SFINAE_ANONYMOUS_BROKEN // see the OString ctors
     158             :     OStringBuffer( const char* value )
     159             :         : pData(NULL)
     160             :     {
     161             :         sal_Int32 length = rtl_str_getLength( value );
     162             :         nCapacity = length + 16;
     163             :         rtl_stringbuffer_newFromStr_WithLength( &pData, value, length );
     164             :     }
     165             : #else
     166             :     template< typename T >
     167           8 :     OStringBuffer( const T& value, typename internal::CharPtrDetector< T, internal::Dummy >::Type = internal::Dummy())
     168           8 :         : pData(NULL)
     169             :     {
     170           8 :         sal_Int32 length = rtl_str_getLength( value );
     171           8 :         nCapacity = length + 16;
     172           8 :         rtl_stringbuffer_newFromStr_WithLength( &pData, value, length );
     173           8 :     }
     174             : 
     175             :     template< typename T >
     176           3 :     OStringBuffer( T& value, typename internal::NonConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy())
     177           3 :         : pData(NULL)
     178             :     {
     179           3 :         sal_Int32 length = rtl_str_getLength( value );
     180           3 :         nCapacity = length + 16;
     181           3 :         rtl_stringbuffer_newFromStr_WithLength( &pData, value, length );
     182           3 :     }
     183             : 
     184             :     /**
     185             :       Constructs a string buffer so that it represents the same
     186             :         sequence of characters as the string literal.
     187             : 
     188             :       If there are any embedded \0's in the string literal, the result is undefined.
     189             :       Use the overload that explicitly accepts length.
     190             : 
     191             :       @since LibreOffice 3.6
     192             : 
     193             :       @param    literal       a string literal
     194             :     */
     195             :     template< typename T >
     196        1902 :     OStringBuffer( T& literal, typename internal::ConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy())
     197             :         : pData(NULL)
     198        1902 :         , nCapacity( internal::ConstCharArrayDetector< T, void >::size - 1 + 16 )
     199             :     {
     200             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     201        1902 :         rtl_string_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 16 );
     202             : #ifdef RTL_STRING_UNITTEST
     203           3 :         rtl_string_unittest_const_literal = true;
     204             : #endif
     205        1902 :     }
     206             : #endif // HAVE_SFINAE_ANONYMOUS_BROKEN
     207             : 
     208             :     /**
     209             :         Constructs a string buffer so that it represents the same
     210             :         sequence of characters as the string argument.
     211             : 
     212             :         The initial
     213             :         capacity of the string buffer is <code>16</code> plus length
     214             : 
     215             :         @param    value       a character array.
     216             :         @param    length      the number of character which should be copied.
     217             :                               The character array length must be greater or
     218             :                               equal than this value.
     219             :      */
     220       35790 :     OStringBuffer(const sal_Char * value, sal_Int32 length)
     221             :         : pData(NULL)
     222       35790 :         , nCapacity( length + 16 )
     223             :     {
     224       35790 :         rtl_stringbuffer_newFromStr_WithLength( &pData, value, length );
     225       35790 :     }
     226             : 
     227             : #ifdef RTL_FAST_STRING
     228             :     /**
     229             :      @overload
     230             :      @internal
     231             :     */
     232             :     template< typename T1, typename T2 >
     233             :     OStringBuffer( const OStringConcat< T1, T2 >& c )
     234             :     {
     235             :         const sal_Int32 l = c.length();
     236             :         nCapacity = l + 16;
     237             :         pData = rtl_string_alloc( nCapacity );
     238             :         char* end = c.addData( pData->buffer );
     239             :         *end = '\0';
     240             :         pData->length = end - pData->buffer;
     241             :     }
     242             : #endif
     243             : 
     244             :     /** Assign to this a copy of value.
     245             :      */
     246           0 :     OStringBuffer& operator = ( const OStringBuffer& value )
     247             :     {
     248           0 :         if (this != &value)
     249             :         {
     250             :             rtl_stringbuffer_newFromStringBuffer(&pData,
     251             :                                                   value.nCapacity,
     252           0 :                                                   value.pData);
     253           0 :             nCapacity = value.nCapacity;
     254             :         }
     255           0 :         return *this;
     256             :     }
     257             : 
     258             :     /**
     259             :         Release the string data.
     260             :      */
     261     3505077 :     ~OStringBuffer()
     262             :     {
     263     3505077 :         rtl_string_release( pData );
     264     3505077 :     }
     265             : 
     266             :     /**
     267             :         Fill the string data in the new string and clear the buffer.
     268             : 
     269             :         This method is more efficient than the contructor of the string. It does
     270             :         not copy the buffer.
     271             : 
     272             :         @return the string previously contained in the buffer.
     273             :      */
     274     2986185 :     OString makeStringAndClear()
     275             :     {
     276     2986185 :         OString aRet( pData );
     277     2986185 :         rtl_string_new(&pData);
     278     2986185 :         nCapacity = 0;
     279     2986185 :         return aRet;
     280             :     }
     281             : 
     282             :     /**
     283             :         Returns the length (character count) of this string buffer.
     284             : 
     285             :         @return  the number of characters in this string buffer.
     286             :      */
     287    26335837 :     sal_Int32 getLength() const
     288             :     {
     289    26335837 :         return pData->length;
     290             :     }
     291             : 
     292             :     /**
     293             :         Returns the current capacity of the String buffer.
     294             : 
     295             :         The capacity
     296             :         is the amount of storage available for newly inserted
     297             :         characters. The real buffer size is 2 bytes longer, because
     298             :         all strings are 0 terminated.
     299             : 
     300             :         @return  the current capacity of this string buffer.
     301             :      */
     302          66 :     sal_Int32 getCapacity() const
     303             :     {
     304          66 :         return nCapacity;
     305             :     }
     306             : 
     307             :     /**
     308             :         Ensures that the capacity of the buffer is at least equal to the
     309             :         specified minimum.
     310             : 
     311             :         The new capacity will be at least as large as the maximum of the current
     312             :         length (so that no contents of the buffer is destroyed) and the given
     313             :         minimumCapacity.  If the given minimumCapacity is negative, nothing is
     314             :         changed.
     315             : 
     316             :         @param   minimumCapacity   the minimum desired capacity.
     317             :      */
     318          17 :     void ensureCapacity(sal_Int32 minimumCapacity)
     319             :     {
     320          17 :         rtl_stringbuffer_ensureCapacity( &pData, &nCapacity, minimumCapacity );
     321          17 :     }
     322             : 
     323             :     /**
     324             :         Sets the length of this String buffer.
     325             : 
     326             :         If the <code>newLength</code> argument is less than the current
     327             :         length of the string buffer, the string buffer is truncated to
     328             :         contain exactly the number of characters given by the
     329             :         <code>newLength</code> argument.
     330             :         <p>
     331             :         If the <code>newLength</code> argument is greater than or equal
     332             :         to the current length, sufficient null characters
     333             :         (<code>'&#92;u0000'</code>) are appended to the string buffer so that
     334             :         length becomes the <code>newLength</code> argument.
     335             :         <p>
     336             :         The <code>newLength</code> argument must be greater than or equal
     337             :         to <code>0</code>.
     338             : 
     339             :         @param      newLength   the new length of the buffer.
     340             :      */
     341     3013682 :     void setLength(sal_Int32 newLength)
     342             :     {
     343             :         assert(newLength >= 0);
     344             :         // Avoid modifications if pData points to const empty string:
     345     3013682 :         if( newLength != pData->length )
     346             :         {
     347        6453 :             if( newLength > nCapacity )
     348        3806 :                 rtl_stringbuffer_ensureCapacity(&pData, &nCapacity, newLength);
     349             :             else
     350        2647 :                 pData->buffer[newLength] = '\0';
     351        6453 :             pData->length = newLength;
     352             :         }
     353     3013682 :     }
     354             : 
     355             :     /**
     356             :         Returns the character at a specific index in this string buffer.
     357             : 
     358             :         The first character of a string buffer is at index
     359             :         <code>0</code>, the next at index <code>1</code>, and so on, for
     360             :         array indexing.
     361             :         <p>
     362             :         The index argument must be greater than or equal to
     363             :         <code>0</code>, and less than the length of this string buffer.
     364             : 
     365             :         @param      index   the index of the desired character.
     366             :         @return     the character at the specified index of this string buffer.
     367             :     */
     368             :     SAL_DEPRECATED("use rtl::OStringBuffer::operator [] instead")
     369             :     sal_Char charAt( sal_Int32 index )
     370             :     {
     371             :         assert(index >= 0 && index < pData->length);
     372             :         return pData->buffer[ index ];
     373             :     }
     374             : 
     375             :     /**
     376             :         The character at the specified index of this string buffer is set
     377             :         to <code>ch</code>.
     378             : 
     379             :         The index argument must be greater than or equal to
     380             :         <code>0</code>, and less than the length of this string buffer.
     381             : 
     382             :         @param      index   the index of the character to modify.
     383             :         @param      ch      the new character.
     384             :      */
     385             :     SAL_DEPRECATED("use rtl::OStringBuffer::operator [] instead")
     386             :     OStringBuffer & setCharAt(sal_Int32 index, sal_Char ch)
     387             :     {
     388             :         assert(index >= 0 && index < pData->length);
     389             :         pData->buffer[ index ] = ch;
     390             :         return *this;
     391             :     }
     392             : 
     393             :     /**
     394             :         Return a null terminated character array.
     395             :      */
     396     1042109 :     const sal_Char* getStr() const { return pData->buffer; }
     397             : 
     398             :     /**
     399             :       Access to individual characters.
     400             : 
     401             :       @param index must be non-negative and less than length.
     402             : 
     403             :       @return a reference to the character at the given index.
     404             : 
     405             :       @since LibreOffice 3.5
     406             :     */
     407      122746 :     sal_Char & operator [](sal_Int32 index) { return pData->buffer[index]; }
     408             : 
     409             :     /**
     410             :         Return a OString instance reflecting the current content
     411             :         of this OStringBuffer.
     412             :      */
     413         256 :     const OString toString() const
     414             :     {
     415         256 :         return OString(pData->buffer, pData->length);
     416             :     }
     417             : 
     418             :     /**
     419             :         Appends the string to this string buffer.
     420             : 
     421             :         The characters of the <code>String</code> argument are appended, in
     422             :         order, to the contents of this string buffer, increasing the
     423             :         length of this string buffer by the length of the argument.
     424             : 
     425             :         @param   str   a string.
     426             :         @return  this string buffer.
     427             :      */
     428     5068742 :     OStringBuffer & append(const OString &str)
     429             :     {
     430     5068742 :         return append( str.getStr(), str.getLength() );
     431             :     }
     432             : 
     433             :     /**
     434             :         Appends the string representation of the <code>char</code> array
     435             :         argument to this string buffer.
     436             : 
     437             :         The characters of the array argument are appended, in order, to
     438             :         the contents of this string buffer. The length of this string
     439             :         buffer increases by the length of the argument.
     440             : 
     441             :         @param   str   the characters to be appended.
     442             :         @return  this string buffer.
     443             :      */
     444             : #ifdef HAVE_SFINAE_ANONYMOUS_BROKEN
     445             :     OStringBuffer & append( const sal_Char * str )
     446             :     {
     447             :         return append( str, rtl_str_getLength( str ) );
     448             :     }
     449             : #else
     450             :     template< typename T >
     451      299472 :     typename internal::CharPtrDetector< T, OStringBuffer& >::Type append( const T& str )
     452             :     {
     453      299472 :         return append( str, rtl_str_getLength( str ) );
     454             :     }
     455             : 
     456             :     template< typename T >
     457        2611 :     typename internal::NonConstCharArrayDetector< T, OStringBuffer& >::Type append( T& str )
     458             :     {
     459        2611 :         return append( str, rtl_str_getLength( str ) );
     460             :     }
     461             : 
     462             :     /**
     463             :      @overload
     464             :      This function accepts an ASCII string literal as its argument.
     465             :      @since LibreOffice 3.6
     466             :     */
     467             :     template< typename T >
     468      366019 :     typename internal::ConstCharArrayDetector< T, OStringBuffer& >::Type append( T& literal )
     469             :     {
     470           2 :         RTL_STRING_CONST_FUNCTION
     471             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     472      366019 :         rtl_stringbuffer_insert( &pData, &nCapacity, getLength(), literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
     473      366019 :         return *this;
     474             :     }
     475             : #endif
     476             : 
     477             :     /**
     478             :         Appends the string representation of the <code>char</code> array
     479             :         argument to this string buffer.
     480             : 
     481             :         Characters of the character array <code>str</code> are appended,
     482             :         in order, to the contents of this string buffer. The length of this
     483             :         string buffer increases by the value of <code>len</code>.
     484             : 
     485             :         @param str the characters to be appended; must be non-null, and must
     486             :         point to at least len characters
     487             :         @param len the number of characters to append; must be non-negative
     488             :         @return  this string buffer.
     489             :      */
     490    22434029 :     OStringBuffer & append( const sal_Char * str, sal_Int32 len)
     491             :     {
     492             :         // insert behind the last character
     493    22434029 :         rtl_stringbuffer_insert( &pData, &nCapacity, getLength(), str, len );
     494    22434029 :         return *this;
     495             :     }
     496             : 
     497             : #ifdef RTL_FAST_STRING
     498             :     /**
     499             :      @overload
     500             :      @internal
     501             :     */
     502             :     template< typename T1, typename T2 >
     503           1 :     OStringBuffer& append( const OStringConcat< T1, T2 >& c )
     504             :     {
     505           1 :         const int l = c.length();
     506           1 :         if( l == 0 )
     507           0 :             return *this;
     508           1 :         rtl_stringbuffer_ensureCapacity( &pData, &nCapacity, pData->length + l );
     509           1 :         char* end = c.addData( pData->buffer + pData->length );
     510           1 :         *end = '\0';
     511           1 :         pData->length = end - pData->buffer;
     512           1 :         return *this;
     513             :     }
     514             : #endif
     515             : 
     516             :     /**
     517             :         Appends the string representation of the <code>sal_Bool</code>
     518             :         argument to the string buffer.
     519             : 
     520             :         The argument is converted to a string as if by the method
     521             :         <code>String.valueOf</code>, and the characters of that
     522             :         string are then appended to this string buffer.
     523             : 
     524             :         @param   b   a <code>sal_Bool</code>.
     525             :         @return  this string buffer.
     526             :      */
     527          19 :     OStringBuffer & append(sal_Bool b)
     528             :     {
     529             :         sal_Char sz[RTL_STR_MAX_VALUEOFBOOLEAN];
     530          19 :         return append( sz, rtl_str_valueOfBoolean( sz, b ) );
     531             :     }
     532             : 
     533             :     /**
     534             :         Appends the string representation of the <code>char</code>
     535             :         argument to this string buffer.
     536             : 
     537             :         The argument is appended to the contents of this string buffer.
     538             :         The length of this string buffer increases by <code>1</code>.
     539             : 
     540             :         @param   c   a <code>char</code>.
     541             :         @return  this string buffer.
     542             :      */
     543    16470751 :     OStringBuffer & append(sal_Char c)
     544             :     {
     545    16470751 :         return append( &c, 1 );
     546             :     }
     547             : 
     548             :     /**
     549             :         Appends the string representation of the <code>sal_Int32</code>
     550             :         argument to this string buffer.
     551             : 
     552             :         The argument is converted to a string as if by the method
     553             :         <code>String.valueOf</code>, and the characters of that
     554             :         string are then appended to this string buffer.
     555             : 
     556             :         @param   i   an <code>sal_Int32</code>.
     557             :         @return  this string buffer.
     558             :      */
     559       42397 :     OStringBuffer & append(sal_Int32 i, sal_Int16 radix = 10 )
     560             :     {
     561             :         sal_Char sz[RTL_STR_MAX_VALUEOFINT32];
     562       42397 :         return append( sz, rtl_str_valueOfInt32( sz, i, radix ) );
     563             :     }
     564             : 
     565             :     /**
     566             :         Appends the string representation of the <code>long</code>
     567             :         argument to this string buffer.
     568             : 
     569             :         The argument is converted to a string as if by the method
     570             :         <code>String.valueOf</code>, and the characters of that
     571             :         string are then appended to this string buffer.
     572             : 
     573             :         @param   l   a <code>long</code>.
     574             :         @return  this string buffer.
     575             :      */
     576         308 :     OStringBuffer & append(sal_Int64 l, sal_Int16 radix = 10 )
     577             :     {
     578             :         sal_Char sz[RTL_STR_MAX_VALUEOFINT64];
     579         308 :         return append( sz, rtl_str_valueOfInt64( sz, l, radix ) );
     580             :     }
     581             : 
     582             :     /**
     583             :         Appends the string representation of the <code>float</code>
     584             :         argument to this string buffer.
     585             : 
     586             :         The argument is converted to a string as if by the method
     587             :         <code>String.valueOf</code>, and the characters of that
     588             :         string are then appended to this string buffer.
     589             : 
     590             :         @param   f   a <code>float</code>.
     591             :         @return  this string buffer.
     592             :      */
     593          50 :     OStringBuffer & append(float f)
     594             :     {
     595             :         sal_Char sz[RTL_STR_MAX_VALUEOFFLOAT];
     596          50 :         return append( sz, rtl_str_valueOfFloat( sz, f ) );
     597             :     }
     598             : 
     599             :     /**
     600             :         Appends the string representation of the <code>double</code>
     601             :         argument to this string buffer.
     602             : 
     603             :         The argument is converted to a string as if by the method
     604             :         <code>String.valueOf</code>, and the characters of that
     605             :         string are then appended to this string buffer.
     606             : 
     607             :         @param   d   a <code>double</code>.
     608             :         @return  this string buffer.
     609             :      */
     610         428 :     OStringBuffer & append(double d)
     611             :     {
     612             :         sal_Char sz[RTL_STR_MAX_VALUEOFDOUBLE];
     613         428 :         return append( sz, rtl_str_valueOfDouble( sz, d ) );
     614             :     }
     615             : 
     616             :     /**
     617             :         Inserts the string into this string buffer.
     618             : 
     619             :         The characters of the <code>String</code> argument are inserted, in
     620             :         order, into this string buffer at the indicated offset. The length
     621             :         of this string buffer is increased by the length of the argument.
     622             :         <p>
     623             :         The offset argument must be greater than or equal to
     624             :         <code>0</code>, and less than or equal to the length of this
     625             :         string buffer.
     626             : 
     627             :         @param      offset   the offset.
     628             :         @param      str      a string.
     629             :         @return     this string buffer.
     630             :      */
     631           0 :     OStringBuffer & insert(sal_Int32 offset, const OString & str)
     632             :     {
     633           0 :         return insert( offset, str.getStr(), str.getLength() );
     634             :     }
     635             : 
     636             :     /**
     637             :         Inserts the string representation of the <code>char</code> array
     638             :         argument into this string buffer.
     639             : 
     640             :         The characters of the array argument are inserted into the
     641             :         contents of this string buffer at the position indicated by
     642             :         <code>offset</code>. The length of this string buffer increases by
     643             :         the length of the argument.
     644             :         <p>
     645             :         The offset argument must be greater than or equal to
     646             :         <code>0</code>, and less than or equal to the length of this
     647             :         string buffer.
     648             : 
     649             :         @param      offset   the offset.
     650             :         @param      str      a character array.
     651             :         @return     this string buffer.
     652             :      */
     653             : #ifdef HAVE_SFINAE_ANONYMOUS_BROKEN
     654             :     OStringBuffer & insert( sal_Int32 offset, const sal_Char * str )
     655             :     {
     656             :         return insert( offset, str, rtl_str_getLength( str ) );
     657             :     }
     658             : #else
     659             :     template< typename T >
     660             :     typename internal::CharPtrDetector< T, OStringBuffer& >::Type insert( sal_Int32 offset, const T& str )
     661             :     {
     662             :         return insert( offset, str, rtl_str_getLength( str ) );
     663             :     }
     664             : 
     665             :     template< typename T >
     666           1 :     typename internal::NonConstCharArrayDetector< T, OStringBuffer& >::Type insert( sal_Int32 offset, T& str )
     667             :     {
     668           1 :         return insert( offset, str, rtl_str_getLength( str ) );
     669             :     }
     670             : 
     671             :     /**
     672             :      @overload
     673             :      This function accepts an ASCII string literal as its argument.
     674             :      @since LibreOffice 3.6
     675             :     */
     676             :     template< typename T >
     677           1 :     typename internal::ConstCharArrayDetector< T, OStringBuffer& >::Type insert( sal_Int32 offset, T& literal )
     678             :     {
     679           1 :         RTL_STRING_CONST_FUNCTION
     680             :         assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
     681           1 :         rtl_stringbuffer_insert( &pData, &nCapacity, offset, literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
     682           1 :         return *this;
     683             :     }
     684             : #endif
     685             : 
     686             :     /**
     687             :         Inserts the string representation of the <code>char</code> array
     688             :         argument into this string buffer.
     689             : 
     690             :         The characters of the array argument are inserted into the
     691             :         contents of this string buffer at the position indicated by
     692             :         <code>offset</code>. The length of this string buffer increases by
     693             :         the length of the argument.
     694             :         <p>
     695             :         The offset argument must be greater than or equal to
     696             :         <code>0</code>, and less than or equal to the length of this
     697             :         string buffer.
     698             : 
     699             :         @param      offset   the offset.
     700             :         @param      str      a character array.
     701             :         @param      len      the number of characters to append.
     702             :         @return     this string buffer.
     703             :      */
     704        7404 :     OStringBuffer & insert( sal_Int32 offset, const sal_Char * str, sal_Int32 len)
     705             :     {
     706             :         // insert behind the last character
     707        7404 :         rtl_stringbuffer_insert( &pData, &nCapacity, offset, str, len );
     708        7404 :         return *this;
     709             :     }
     710             : 
     711             :     /**
     712             :         Inserts the string representation of the <code>sal_Bool</code>
     713             :         argument into this string buffer.
     714             : 
     715             :         The second argument is converted to a string as if by the method
     716             :         <code>String.valueOf</code>, and the characters of that
     717             :         string are then inserted into this string buffer at the indicated
     718             :         offset.
     719             :         <p>
     720             :         The offset argument must be greater than or equal to
     721             :         <code>0</code>, and less than or equal to the length of this
     722             :         string buffer.
     723             : 
     724             :         @param      offset   the offset.
     725             :         @param      b        a <code>sal_Bool</code>.
     726             :         @return     this string buffer.
     727             :      */
     728             :     OStringBuffer & insert(sal_Int32 offset, sal_Bool b)
     729             :     {
     730             :         sal_Char sz[RTL_STR_MAX_VALUEOFBOOLEAN];
     731             :         return insert( offset, sz, rtl_str_valueOfBoolean( sz, b ) );
     732             :     }
     733             : 
     734             :     /**
     735             :         Inserts the string representation of the <code>char</code>
     736             :         argument into this string buffer.
     737             : 
     738             :         The second argument is inserted into the contents of this string
     739             :         buffer at the position indicated by <code>offset</code>. The length
     740             :         of this string buffer increases by one.
     741             :         <p>
     742             :         The offset argument must be greater than or equal to
     743             :         <code>0</code>, and less than or equal to the length of this
     744             :         string buffer.
     745             : 
     746             :         @param      offset   the offset.
     747             :         @param      c        a <code>char</code>.
     748             :         @return     this string buffer.
     749             :      */
     750           0 :     OStringBuffer & insert(sal_Int32 offset, sal_Char c)
     751             :     {
     752           0 :         return insert( offset, &c, 1 );
     753             :     }
     754             : 
     755             :     /**
     756             :         Inserts the string representation of the second <code>sal_Int32</code>
     757             :         argument into this string buffer.
     758             : 
     759             :         The second argument is converted to a string as if by the method
     760             :         <code>String.valueOf</code>, and the characters of that
     761             :         string are then inserted into this string buffer at the indicated
     762             :         offset.
     763             :         <p>
     764             :         The offset argument must be greater than or equal to
     765             :         <code>0</code>, and less than or equal to the length of this
     766             :         string buffer.
     767             : 
     768             :         @param      offset   the offset.
     769             :         @param      i        an <code>sal_Int32</code>.
     770             :         @return     this string buffer.
     771             :      */
     772             :     OStringBuffer & insert(sal_Int32 offset, sal_Int32 i, sal_Int16 radix = 10 )
     773             :     {
     774             :         sal_Char sz[RTL_STR_MAX_VALUEOFINT32];
     775             :         return insert( offset, sz, rtl_str_valueOfInt32( sz, i, radix ) );
     776             :     }
     777             : 
     778             :     /**
     779             :         Inserts the string representation of the <code>long</code>
     780             :         argument into this string buffer.
     781             : 
     782             :         The second argument is converted to a string as if by the method
     783             :         <code>String.valueOf</code>, and the characters of that
     784             :         string are then inserted into this string buffer at the indicated
     785             :         offset.
     786             :         <p>
     787             :         The offset argument must be greater than or equal to
     788             :         <code>0</code>, and less than or equal to the length of this
     789             :         string buffer.
     790             : 
     791             :         @param      offset   the offset.
     792             :         @param      l        a <code>long</code>.
     793             :         @return     this string buffer.
     794             :      */
     795             :     OStringBuffer & insert(sal_Int32 offset, sal_Int64 l, sal_Int16 radix = 10 )
     796             :     {
     797             :         sal_Char sz[RTL_STR_MAX_VALUEOFINT64];
     798             :         return insert( offset, sz, rtl_str_valueOfInt64( sz, l, radix ) );
     799             :     }
     800             : 
     801             :     /**
     802             :         Inserts the string representation of the <code>float</code>
     803             :         argument into this string buffer.
     804             : 
     805             :         The second argument is converted to a string as if by the method
     806             :         <code>String.valueOf</code>, and the characters of that
     807             :         string are then inserted into this string buffer at the indicated
     808             :         offset.
     809             :         <p>
     810             :         The offset argument must be greater than or equal to
     811             :         <code>0</code>, and less than or equal to the length of this
     812             :         string buffer.
     813             : 
     814             :         @param      offset   the offset.
     815             :         @param      f        a <code>float</code>.
     816             :         @return     this string buffer.
     817             :      */
     818             :     OStringBuffer insert(sal_Int32 offset, float f)
     819             :     {
     820             :         sal_Char sz[RTL_STR_MAX_VALUEOFFLOAT];
     821             :         return insert( offset, sz, rtl_str_valueOfFloat( sz, f ) );
     822             :     }
     823             : 
     824             :     /**
     825             :         Inserts the string representation of the <code>double</code>
     826             :         argument into this string buffer.
     827             : 
     828             :         The second argument is converted to a string as if by the method
     829             :         <code>String.valueOf</code>, and the characters of that
     830             :         string are then inserted into this string buffer at the indicated
     831             :         offset.
     832             :         <p>
     833             :         The offset argument must be greater than or equal to
     834             :         <code>0</code>, and less than or equal to the length of this
     835             :         string buffer.
     836             : 
     837             :         @param      offset   the offset.
     838             :         @param      d        a <code>double</code>.
     839             :         @return     this string buffer.
     840             :      */
     841             :     OStringBuffer & insert(sal_Int32 offset, double d)
     842             :     {
     843             :         sal_Char sz[RTL_STR_MAX_VALUEOFDOUBLE];
     844             :         return insert( offset, sz, rtl_str_valueOfDouble( sz, d ) );
     845             :     }
     846             : 
     847             :     /**
     848             :         Removes the characters in a substring of this sequence.
     849             : 
     850             :         The substring begins at the specified <code>start</code> and
     851             :         is <code>len</code> characters long.
     852             : 
     853             :         start must be >= 0 && <= getLength() && <= end
     854             : 
     855             :         @param  start       The beginning index, inclusive
     856             :         @param  len         The substring length
     857             :         @return this string buffer.
     858             :      */
     859         978 :     OStringBuffer & remove( sal_Int32 start, sal_Int32 len )
     860             :     {
     861         978 :         rtl_stringbuffer_remove( &pData, start, len );
     862         978 :         return *this;
     863             :     }
     864             : 
     865             : #ifdef LIBO_INTERNAL_ONLY
     866             :     // This is to complement the RTL_FAST_STRING operator+, which allows any combination of valid operands,
     867             :     // even two buffers. It's intentional it returns OString, just like the operator+ would in the fast variant.
     868             : #ifndef RTL_FAST_STRING
     869             :     /**
     870             :      @internal
     871             :      @since LibreOffice 4.1
     872             :     */
     873             :     friend OString operator+( const OStringBuffer& str1, const OStringBuffer& str2  ) SAL_THROW(())
     874             :     {
     875             :         return OString( str1.pData ).concat( str2.pData );
     876             :     }
     877             : #endif
     878             : #endif
     879             : 
     880             : private:
     881             :     /**
     882             :         A pointer to the data structur which contains the data.
     883             :      */
     884             :     rtl_String * pData;
     885             : 
     886             :     /**
     887             :         The len of the pData->buffer.
     888             :      */
     889             :     sal_Int32       nCapacity;
     890             : };
     891             : 
     892             : #ifdef RTL_FAST_STRING
     893             : /**
     894             :  @internal
     895             : */
     896             : template<>
     897             : struct ToStringHelper< OStringBuffer >
     898             :     {
     899           1 :     static int length( const OStringBuffer& s ) { return s.getLength(); }
     900           1 :     static char* addData( char* buffer, const OStringBuffer& s ) { return addDataHelper( buffer, s.getStr(), s.getLength()); }
     901             :     static const bool allowOStringConcat = true;
     902             :     static const bool allowOUStringConcat = false;
     903             :     };
     904             : #endif
     905             : 
     906             : 
     907             : }
     908             : 
     909             : #ifdef RTL_STRING_UNITTEST
     910             : namespace rtl
     911             : {
     912             : typedef rtlunittest::OStringBuffer OStringBuffer;
     913             : }
     914             : #undef RTL_STRING_CONST_FUNCTION
     915             : #endif
     916             : 
     917             : #ifdef RTL_USING
     918             : using ::rtl::OStringBuffer;
     919             : #endif
     920             : 
     921             : #endif  /* __cplusplus */
     922             : #endif  /* _RTL_STRBUF_HXX_ */
     923             : 
     924             : 
     925             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10