ustrbuf.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
/*
 * This file is part of LibreOffice published API.
 */
 
#ifndef INCLUDED_RTL_USTRBUF_HXX
#define INCLUDED_RTL_USTRBUF_HXX
 
#include "sal/config.h"
 
#include <cassert>
#include <cstring>
#include <limits>
#include <new>
 
#if defined LIBO_INTERNAL_ONLY
#include <string_view>
#include <type_traits>
#include <utility>
#endif
 
#include "rtl/ustrbuf.h"
#include "rtl/ustring.hxx"
#include "rtl/stringutils.hxx"
#include "sal/types.h"
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
#include "o3tl/safeint.hxx"
#include "rtl/stringconcat.hxx"
#endif
 
#ifdef RTL_STRING_UNITTEST
extern bool rtl_string_unittest_invalid_conversion;
#endif
 
// The unittest uses slightly different code to help check that the proper
// calls are made. The class is put into a different namespace to make
// sure the compiler generates a different (if generating also non-inline)
// copy of the function and does not merge them together. The class
// is "brought" into the proper rtl namespace by a typedef below.
#ifdef RTL_STRING_UNITTEST
#define rtl rtlunittest
#endif
 
namespace rtl
{
 
#ifdef RTL_STRING_UNITTEST
#undef rtl
#endif

class SAL_WARN_UNUSED OUStringBuffer
{
friend class OUString;
public:
    OUStringBuffer()
        : pData(NULL)
        , nCapacity( 16 )
    {
        rtl_uString_new_WithLength( &pData, nCapacity );
    }

    OUStringBuffer( const OUStringBuffer & value )
        : pData(NULL)
        , nCapacity( value.nCapacity )
    {
        rtl_uStringbuffer_newFromStringBuffer( &pData, value.nCapacity, value.pData );
    }

    explicit OUStringBuffer(sal_Int32 length)
        : pData(NULL)
        , nCapacity( length )
    {
        rtl_uString_new_WithLength( &pData, length );
    }
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    explicit OUStringBuffer(T length, std::enable_if_t<std::is_integral_v<T>, int> = 0)
        : OUStringBuffer(static_cast<sal_Int32>(length))
    {
        assert(libreoffice_internal::IsValidStrLen(length));
    }
    // avoid (obvious) bugs
    explicit OUStringBuffer(bool) = delete;
    explicit OUStringBuffer(char) = delete;
    explicit OUStringBuffer(wchar_t) = delete;
#if !(defined _MSC_VER && _MSC_VER >= 1930 && _MSC_VER <= 1939 && defined _MANAGED)
    explicit OUStringBuffer(char8_t) = delete;
#endif
    explicit OUStringBuffer(char16_t) = delete;
    explicit OUStringBuffer(char32_t) = delete;
#endif

#if defined LIBO_INTERNAL_ONLY
    OUStringBuffer(std::u16string_view sv)
        : pData(nullptr)
        , nCapacity(libreoffice_internal::ThrowIfInvalidStrLen(sv.length(), 16) + 16)
    {
        rtl_uStringbuffer_newFromStr_WithLength( &pData, sv.data(), sv.length() );
    }
#else
    OUStringBuffer(const OUString& value)
        : pData(NULL)
        , nCapacity( value.getLength() + 16 )
    {
        rtl_uStringbuffer_newFromStr_WithLength( &pData, value.getStr(), value.getLength() );
    }
#endif
 
    template< typename T >
    OUStringBuffer( T& literal, typename libreoffice_internal::ConstCharArrayDetector< T, libreoffice_internal::Dummy >::Type = libreoffice_internal::Dummy() )
        : pData(NULL)
        , nCapacity( libreoffice_internal::ConstCharArrayDetector<T>::length + 16 )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        rtl_uString_newFromLiteral(
            &pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length, 16);
#ifdef RTL_STRING_UNITTEST
        rtl_string_unittest_const_literal = true;
#endif
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    OUStringBuffer(
        T & literal,
        typename libreoffice_internal::ConstCharArrayDetector<
            T, libreoffice_internal::Dummy>::TypeUtf16
                = libreoffice_internal::Dummy()):
        pData(nullptr),
        nCapacity(libreoffice_internal::ConstCharArrayDetector<T>::length + 16)
    {
        rtl_uStringbuffer_newFromStr_WithLength(
            &pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY && defined RTL_STRING_UNITTEST

    template< typename T >
    OUStringBuffer( T&, typename libreoffice_internal::ExceptConstCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        nCapacity = 10;
        rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
        rtl_string_unittest_invalid_conversion = true;
    }
    template< typename T >
    OUStringBuffer( const T&, typename libreoffice_internal::ExceptCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        nCapacity = 10;
        rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
        rtl_string_unittest_invalid_conversion = true;
    }
#endif
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    template< typename T1, typename T2 >
    OUStringBuffer( OUStringConcat< T1, T2 >&& c )
    {
        const sal_Int32 l = c.length();
        nCapacity = l + 16;
        pData = rtl_uString_alloc( nCapacity );
        sal_Unicode* end = c.addData( pData->buffer );
        *end = '\0';
        pData->length = l;
    }

    template< std::size_t N >
    OUStringBuffer( OUStringNumber< N >&& n )
        : OUStringBuffer(std::u16string_view(n))
    {
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    operator std::u16string_view() const { return {getStr(), sal_uInt32(getLength())}; }
#endif

    OUStringBuffer& operator = ( const OUStringBuffer& value )
    {
        if (this != &value)
        {
            rtl_uStringbuffer_newFromStringBuffer(&pData,
                                                  value.nCapacity,
                                                  value.pData);
            nCapacity = value.nCapacity;
        }
        return *this;
    }
 
#if defined LIBO_INTERNAL_ONLY
    OUStringBuffer& operator = ( OUStringBuffer&& value ) noexcept
    {
        rtl_uString_release( pData );
        pData = value.pData;
        nCapacity = value.nCapacity;
        value.pData = nullptr;
        value.nCapacity = 0;
        rtl_uString_new( &value.pData );
        return *this;
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    OUStringBuffer & operator =(std::u16string_view string) {
        sal_Int32 n = string.length();
        if (n >= nCapacity) {
            ensureCapacity(n + 16); //TODO: check for overflow
        }
        std::memcpy(
            pData->buffer, string.data(),
            n * sizeof (sal_Unicode));
        pData->buffer[n] = '\0';
        pData->length = n;
        return *this;
    }
#else
    OUStringBuffer & operator =(OUString const & string) {
        sal_Int32 n = string.getLength();
        if (n >= nCapacity) {
            ensureCapacity(n + 16); //TODO: check for overflow
        }
        std::memcpy(
            pData->buffer, string.pData->buffer,
            (n + 1) * sizeof (sal_Unicode));
        pData->length = n;
        return *this;
    }
#endif

    template<typename T>
    typename
        libreoffice_internal::ConstCharArrayDetector<T, OUStringBuffer &>::Type
    operator =(T & literal) {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        sal_Int32 const n
            = libreoffice_internal::ConstCharArrayDetector<T>::length;
        if (n >= nCapacity) {
            ensureCapacity(n + 16); //TODO: check for overflow
        }
        char const * from
            = libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                literal);
        sal_Unicode * to = pData->buffer;
        for (sal_Int32 i = 0; i <= n; ++i) {
            to[i] = from[i];
        }
        pData->length = n;
        return *this;
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename libreoffice_internal::ConstCharArrayDetector<
        T, OUStringBuffer &>::TypeUtf16
    operator =(T & literal) {
        return operator=(
            std::u16string_view(libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
                                libreoffice_internal::ConstCharArrayDetector<T>::length));
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T1, typename T2>
    OUStringBuffer & operator =(OUStringConcat<T1, T2> && concat) {
        sal_Int32 const n = concat.length();
        if (n >= nCapacity) {
            ensureCapacity(n + 16); //TODO: check for overflow
        }
        *concat.addData(pData->buffer) = 0;
        pData->length = n;
        return *this;
    }

    template<std::size_t N>
    OUStringBuffer & operator =(OUStringNumber<N> && n)
    {
        return operator =(std::u16string_view(n));
    }
#endif

    ~OUStringBuffer()
    {
        rtl_uString_release( pData );
    }

    SAL_WARN_UNUSED_RESULT OUString makeStringAndClear()
    {
        return OUString(
                  rtl_uStringBuffer_makeStringAndClear( &pData, &nCapacity ),
                  SAL_NO_ACQUIRE );
    }

    sal_Int32 getLength() const
    {
        return pData->length;
    }

    bool isEmpty() const
    {
        return pData->length == 0;
    }

    sal_Int32 getCapacity() const
    {
        return nCapacity;
    }

    void ensureCapacity(sal_Int32 minimumCapacity)
    {
        rtl_uStringbuffer_ensureCapacity( &pData, &nCapacity, minimumCapacity );
    }

    void setLength(sal_Int32 newLength)
    {
        assert(newLength >= 0);
        // Avoid modifications if pData points to const empty string:
        if( newLength != pData->length )
        {
            if( newLength > nCapacity )
                rtl_uStringbuffer_ensureCapacity(&pData, &nCapacity, newLength);
            else
                pData->buffer[newLength] = 0;
            pData->length = newLength;
        }
    }

    SAL_DEPRECATED("use rtl::OUStringBuffer::operator [] instead")
    sal_Unicode charAt( sal_Int32 index ) const
    {
        assert(index >= 0 && index < pData->length);
        return pData->buffer[ index ];
    }

    SAL_DEPRECATED("use rtl::OUStringBuffer::operator [] instead")
    OUStringBuffer & setCharAt(sal_Int32 index, sal_Unicode ch)
    {
        assert(index >= 0 && index < pData->length);
        pData->buffer[ index ] = ch;
        return *this;
    }

    const sal_Unicode*  getStr() const SAL_RETURNS_NONNULL { return pData->buffer; }
 
#if defined LIBO_INTERNAL_ONLY
    // Provide unsafe non-const access to the null-terminated string.  Callers can mutate the
    // contents of the string buffer (including introducing embedded null characters), but cannot
    // modify its length.
    sal_Unicode * getMutableStr() SAL_RETURNS_NONNULL { return pData->buffer; }
#endif

    sal_Unicode & operator [](sal_Int32 index)
    {
        assert(index >= 0 && index < pData->length);
        return pData->buffer[index];
    }

    const sal_Unicode & operator [](sal_Int32 index) const
    {
        assert(index >= 0 && index < pData->length);
        return pData->buffer[index];
    }

    OUString toString() const
    {
        return OUString(pData->buffer, pData->length);
    }

#if !defined LIBO_INTERNAL_ONLY
    OUStringBuffer & append(const OUString &str)
#else
    OUStringBuffer & append(std::u16string_view str)
#endif
    {
        return insert(getLength(), str);
    }
 
#if !defined LIBO_INTERNAL_ONLY
    OUStringBuffer & append(const OUStringBuffer &str)
    {
        if(!str.isEmpty())
        {
            append( str.getStr(), str.getLength() );
        }
        return *this;
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename libreoffice_internal::CharPtrDetector<T, OUStringBuffer &>::TypeUtf16
    append(T const & str)
#else
    OUStringBuffer & append( const sal_Unicode * str )
#endif
    {
        return insert(getLength(), str);
    }

    OUStringBuffer & append( const sal_Unicode * str, sal_Int32 len)
    {
        return insert(getLength(), str, len);
    }

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, OUStringBuffer& >::Type append( T& literal )
    {
        return insert(getLength(), literal);
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename libreoffice_internal::NonConstCharArrayDetector<T, OUStringBuffer &>::TypeUtf16
    append(T & value) { return append(static_cast<sal_Unicode *>(value)); }

    template<typename T>
    typename libreoffice_internal::ConstCharArrayDetector<
        T, OUStringBuffer &>::TypeUtf16
    append(T & literal) {
        return insert(getLength(), literal);
    }
#endif
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    template< typename T1, typename T2 >
    OUStringBuffer& append( OUStringConcat< T1, T2 >&& c )
    {
        return insert(getLength(), std::move(c));
    }
#endif

    OUStringBuffer & appendAscii( const char * str )
    {
        return appendAscii( str, rtl_str_getLength( str ) );
    }

    OUStringBuffer & appendAscii( const char * str, sal_Int32 len)
    {
        rtl_uStringbuffer_insert_ascii( &pData, &nCapacity, getLength(), str, len );
        return *this;
    }

    OUStringBuffer & append(bool b)
    {
        return insert(getLength(), b);
    }

    // Pointer can be automatically converted to bool, which is unwanted here.
    // Explicitly delete all pointer append() overloads to prevent this
    // (except for char* and sal_Unicode* overloads, which are handled elsewhere).
    template< typename T >
    typename libreoffice_internal::Enable< void,
        !libreoffice_internal::CharPtrDetector< T* >::ok && !libreoffice_internal::SalUnicodePtrDetector< T* >::ok >::Type
        append( T* ) SAL_DELETED_FUNCTION;
 
    // This overload is needed because OUString has a ctor from rtl_uString*, but
    // the bool overload above would be preferred to the conversion.
    OUStringBuffer & append(rtl_uString* str)
    {
        return append( OUString::unacquired( &str ));
    }

    OUStringBuffer & append(sal_Bool b)
    {
        return insert(getLength(), b);
    }

    OUStringBuffer & append(char c)
    {
        assert(static_cast< unsigned char >(c) <= 0x7F);
        return insert(getLength(), c);
    }

    OUStringBuffer & append(sal_Unicode c)
    {
        return insert(getLength(), c);
    }
 
#if defined LIBO_INTERNAL_ONLY
    void append(sal_uInt16) = delete;
#endif

    OUStringBuffer & append(sal_Int32 i, sal_Int16 radix = 10 )
    {
        return insert(getLength(), i, radix);
    }

    OUStringBuffer & append(sal_Int64 l, sal_Int16 radix = 10 )
    {
        return insert(getLength(), l, radix);
    }

    OUStringBuffer & append(float f)
    {
        return insert(getLength(), f);
    }

    OUStringBuffer & append(double d)
    {
        return insert(getLength(), d);
    }

    OUStringBuffer & appendUtf32(sal_uInt32 c) {
        return insertUtf32(getLength(), c);
    }

    sal_Unicode * appendUninitialized(sal_Int32 length) SAL_RETURNS_NONNULL {
        sal_Int32 n = getLength();
        rtl_uStringbuffer_insert(&pData, &nCapacity, n, NULL, length);
        return pData->buffer + n;
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    OUStringBuffer& operator<<(T&& rValue)
    {
        return append(std::forward<T>(rValue));
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    OUStringBuffer & insert(sal_Int32 offset, std::u16string_view str)
    {
        return insert(offset, str.data(), libreoffice_internal::ThrowIfInvalidStrLen(str.length()));
    }
#else
    OUStringBuffer & insert(sal_Int32 offset, const OUString & str)
    {
        return insert( offset, str.getStr(), str.getLength() );
    }
#endif
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    template <typename T1, typename T2>
    OUStringBuffer& insert(sal_Int32 offset, OUStringConcat<T1, T2>&& c)
    {
        const size_t l = c.length();
        if (l == 0)
            return *this;
        if (l > o3tl::make_unsigned(std::numeric_limits<sal_Int32>::max() - pData->length))
            throw std::bad_alloc();
 
        rtl_uStringbuffer_insert(&pData, &nCapacity, offset, nullptr, l);
 
        /* insert the new characters */
        c.addData(pData->buffer + offset);
        return *this;
    }
#endif

    OUStringBuffer & insert( sal_Int32 offset, const sal_Unicode * str )
    {
        return insert( offset, str, rtl_ustr_getLength( str ) );
    }

    OUStringBuffer & insert( sal_Int32 offset, const sal_Unicode * str, sal_Int32 len)
    {
        assert( len == 0 || str != NULL ); // cannot assert that in rtl_uStringbuffer_insert
        rtl_uStringbuffer_insert( &pData, &nCapacity, offset, str, len );
        return *this;
    }

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, OUStringBuffer& >::Type insert( sal_Int32 offset, T& literal )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        rtl_uStringbuffer_insert_ascii(
            &pData, &nCapacity, offset,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return *this;
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename libreoffice_internal::ConstCharArrayDetector<
        T, OUStringBuffer &>::TypeUtf16
    insert(sal_Int32 offset, T & literal) {
        return insert(
            offset,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }
#endif

    OUStringBuffer & insert(sal_Int32 offset, sal_Bool b)
    {
        sal_Unicode sz[RTL_USTR_MAX_VALUEOFBOOLEAN];
        return insert( offset, sz, rtl_ustr_valueOfBoolean( sz, b ) );
    }

    OUStringBuffer & insert(sal_Int32 offset, bool b)
    {
        sal_Unicode sz[RTL_USTR_MAX_VALUEOFBOOLEAN];
        return insert( offset, sz, rtl_ustr_valueOfBoolean( sz, b ) );
    }

    OUStringBuffer & insert(sal_Int32 offset, char c)
    {
        return insert(offset, sal_Unicode(c));
    }

    OUStringBuffer & insert(sal_Int32 offset, sal_Unicode c)
    {
        return insert( offset, &c, 1 );
    }

    OUStringBuffer & insert(sal_Int32 offset, sal_Int32 i, sal_Int16 radix = 10 )
    {
        sal_Unicode sz[RTL_USTR_MAX_VALUEOFINT32];
        return insert( offset, sz, rtl_ustr_valueOfInt32( sz, i, radix ) );
    }

    OUStringBuffer & insert(sal_Int32 offset, sal_Int64 l, sal_Int16 radix = 10 )
    {
        sal_Unicode sz[RTL_USTR_MAX_VALUEOFINT64];
        return insert( offset, sz, rtl_ustr_valueOfInt64( sz, l, radix ) );
    }

    OUStringBuffer & insert(sal_Int32 offset, float f)
    {
        // Same as rtl::str::valueOfFP, used for rtl_ustr_valueOfFloat
        rtl_math_doubleToUString(&pData, &nCapacity, offset, f, rtl_math_StringFormat_G,
                                 RTL_USTR_MAX_VALUEOFFLOAT - SAL_N_ELEMENTS("-x.E-xxx") + 1, '.',
                                 NULL, 0, true);
        return *this;
    }

    OUStringBuffer & insert(sal_Int32 offset, double d)
    {
        // Same as rtl::str::valueOfFP, used for rtl_ustr_valueOfDouble
        rtl_math_doubleToUString(&pData, &nCapacity, offset, d, rtl_math_StringFormat_G,
                                 RTL_USTR_MAX_VALUEOFDOUBLE - SAL_N_ELEMENTS("-x.E-xxx") + 1, '.',
                                 NULL, 0, true);
        return *this;
    }

    OUStringBuffer & insertUtf32(sal_Int32 offset, sal_uInt32 c) {
        rtl_uStringbuffer_insertUtf32(&pData, &nCapacity, offset, c);
        return *this;
    }

    OUStringBuffer & remove( sal_Int32 start, sal_Int32 len )
    {
        rtl_uStringbuffer_remove( &pData, start, len );
        return *this;
    }

    OUStringBuffer & truncate( sal_Int32 start = 0 )
    {
        rtl_uStringbuffer_remove( &pData, start, getLength() - start );
        return *this;
    }

    OUStringBuffer& replace( sal_Unicode oldChar, sal_Unicode newChar )
    {
        sal_Int32 index = 0;
        while((index = indexOf(oldChar, index)) >= 0)
        {
            pData->buffer[ index ] = newChar;
        }
        return *this;
    }

    void accessInternals(rtl_uString *** pInternalData,
                                sal_Int32 ** pInternalCapacity)
    {
        *pInternalData = &pData;
        *pInternalCapacity = &nCapacity;
    }
 

    sal_Int32 indexOf( sal_Unicode ch, sal_Int32 fromIndex = 0 ) const
    {
        assert( fromIndex >= 0 && fromIndex <= pData->length );
        sal_Int32 ret = rtl_ustr_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
        return (ret < 0 ? ret : ret+fromIndex);
    }

    sal_Int32 lastIndexOf( sal_Unicode ch ) const
    {
        return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
    }

    sal_Int32 lastIndexOf( sal_Unicode ch, sal_Int32 fromIndex ) const
    {
        assert( fromIndex >= 0 && fromIndex <= pData->length );
        return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
    }

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 indexOf( std::u16string_view str, sal_Int32 fromIndex = 0 ) const
    {
        assert( fromIndex >= 0 && fromIndex <= pData->length );
        sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                        str.data(), str.length() );
        return (ret < 0 ? ret : ret+fromIndex);
    }
#else
    sal_Int32 indexOf( const OUString & str, sal_Int32 fromIndex = 0 ) const
    {
        assert( fromIndex >= 0 && fromIndex <= pData->length );
        sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                        str.pData->buffer, str.pData->length );
        return (ret < 0 ? ret : ret+fromIndex);
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        sal_Int32 n = rtl_ustr_indexOfAscii_WithLength(
            pData->buffer + fromIndex, pData->length - fromIndex,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return n < 0 ? n : n + fromIndex;
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename
        libreoffice_internal::ConstCharArrayDetector<T, sal_Int32>::TypeUtf16
    indexOf(T & literal, sal_Int32 fromIndex = 0) const {
        return indexOf(
            std::u16string_view(libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
                                libreoffice_internal::ConstCharArrayDetector<T>::length),
            fromIndex);
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 lastIndexOf( std::u16string_view str ) const
    {
        return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length,
                                                   str.data(), str.length() );
    }
#else
    sal_Int32 lastIndexOf( const OUString & str ) const
    {
        return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length,
                                                   str.pData->buffer, str.pData->length );
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 lastIndexOf( std::u16string_view str, sal_Int32 fromIndex ) const
    {
        assert( fromIndex >= 0 && fromIndex <= pData->length );
        return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
                                                   str.data(), str.length() );
    }
#else
    sal_Int32 lastIndexOf( const OUString & str, sal_Int32 fromIndex ) const
    {
        assert( fromIndex >= 0 && fromIndex <= pData->length );
        return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
                                                   str.pData->buffer, str.pData->length );
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf( T& literal ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return rtl_ustr_lastIndexOfAscii_WithLength(
            pData->buffer, pData->length,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename
        libreoffice_internal::ConstCharArrayDetector<T, sal_Int32>::TypeUtf16
    lastIndexOf(T & literal) const {
        return lastIndexOf(
            std::u16string_view(libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
                                libreoffice_internal::ConstCharArrayDetector<T>::length));
    }
#endif

    sal_Int32 stripStart(sal_Unicode c = ' ')
    {
        sal_Int32 index;
        for(index = 0; index < getLength() ; index++)
        {
            if(pData->buffer[ index ] != c)
            {
                break;
            }
        }
        if(index)
        {
            remove(0, index);
        }
        return index;
    }

    sal_Int32 stripEnd(sal_Unicode c = ' ')
    {
        sal_Int32 result = getLength();
        sal_Int32 index;
        for(index = getLength(); index > 0 ; index--)
        {
            if(pData->buffer[ index - 1 ] != c)
            {
                break;
            }
        }
        if(index < getLength())
        {
            truncate(index);
        }
        return result - getLength();
    }

    sal_Int32 strip(sal_Unicode c = ' ')
    {
        return stripStart(c) + stripEnd(c);
    }
 
#if defined LIBO_INTERNAL_ONLY
    SAL_WARN_UNUSED_RESULT std::u16string_view subView( sal_Int32 beginIndex ) const
    {
        assert(beginIndex >= 0);
        assert(beginIndex <= getLength());
        return subView(beginIndex, getLength() - beginIndex);
    }

    SAL_WARN_UNUSED_RESULT std::u16string_view subView( sal_Int32 beginIndex, sal_Int32 count ) const
    {
        assert(beginIndex >= 0);
        assert(count >= 0);
        assert(beginIndex <= getLength());
        assert(count <= getLength() - beginIndex);
        return std::u16string_view(*this).substr(beginIndex, count);
    }
#endif

    OUStringBuffer copy( sal_Int32 beginIndex ) const
    {
        return copy( beginIndex, getLength() - beginIndex );
    }

    OUStringBuffer copy( sal_Int32 beginIndex, sal_Int32 count ) const
    {
        assert(beginIndex >= 0 && beginIndex <= getLength());
        assert(count >= 0 && count <= getLength() - beginIndex);
        rtl_uString *pNew = NULL;
        rtl_uStringbuffer_newFromStr_WithLength( &pNew, getStr() + beginIndex, count );
        return OUStringBuffer( pNew, count + 16 );
    }
 
private:
    OUStringBuffer( rtl_uString * value, const sal_Int32 capacity )
    {
        pData = value;
        nCapacity = capacity;
    }

    rtl_uString * pData;

    sal_Int32       nCapacity;
};
 
#if defined LIBO_INTERNAL_ONLY
template<> struct ToStringHelper<OUStringBuffer> {
    static std::size_t length(OUStringBuffer const & s) { return s.getLength(); }
 
    sal_Unicode * operator()(sal_Unicode * buffer, OUStringBuffer const & s) const SAL_RETURNS_NONNULL
    { return addDataHelper(buffer, s.getStr(), s.getLength()); }
};
#endif
 
#if defined LIBO_INTERNAL_ONLY
    // Define this here to avoid circular includes
    inline OUString & OUString::operator+=( const OUStringBuffer & str ) &
    {
        // Call operator= if this is empty, otherwise rtl_uString_newConcat will attempt to
        // acquire() the str.pData buffer, which is part of the OUStringBuffer mutable state.
        if (isEmpty())
            return operator=(str.toString());
        else
            return internalAppend(str.pData);
    }
 
    inline OUString const& OUString::unacquired(const OUStringBuffer& str)
    {
        return unacquired(&str.pData);
    }
#endif
}
 
#ifdef RTL_STRING_UNITTEST
namespace rtl
{
typedef rtlunittest::OUStringBuffer OUStringBuffer;
}
#endif
 
#if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
using ::rtl::OUStringBuffer;
#endif
 
#endif // INCLUDED_RTL_USTRBUF_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */